$VAR1 = {
          '' => '
#
# Stub version of: 
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  
  return $rc;
}
',
          '\\EFo' => '
#
# Stub version of: \\EFo
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\EO4A' => '
#
# Stub version of: \\EO4A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(52); # 4
  $rc .= chr(65); # A

  return $rc;
}
',
          '^^FG' => '
#
# Stub version of: ^^FG
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(70); # F
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\377\\310' => '
#
# Stub version of: \\377\\310
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(200); # \\310

  return $rc;
}
',
          '\\E7F4\\E7B1\\013\\E7F7\\E7B0' => '
#
# Stub version of: \\E7F4\\E7B1\\013\\E7F7\\E7B0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(66); # B
  $rc .= chr(49); # 1
  $rc .= chr(11); # \\013
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(70); # F
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(66); # B
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\EARF' => '
#
# Stub version of: \\EARF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(82); # R
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E[2;1H' => '
#
# Stub version of: \\E[2;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E]' => '
#
# Stub version of: \\E]
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]

  return $rc;
}
',
          '\\E[>1;7C' => '
#
# Stub version of: \\E[>1;7C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[%p1%d@$<7>' => '
#
# Stub version of: \\E[%p1%d@$<7>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(64); # @
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO5H' => '
#
# Stub version of: \\EO5H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(53); # 5
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E]s\\E9\\E]W' => '
#
# Stub version of: \\E]s\\E9\\E]W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(87); # W

  return $rc;
}
',
          '+z\\,{-x.yOi`|jGkFlEmDnHqJtLuKvNwMxI' => '
#
# Stub version of: +z\\,{-x.yOi`|jGkFlEmDnHqJtLuKvNwMxI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(122); # z
  $rc .= chr(128); # \\,
  $rc .= chr(123); # {
  $rc .= chr(45); # -
  $rc .= chr(120); # x
  $rc .= chr(46); # .
  $rc .= chr(121); # y
  $rc .= chr(79); # O
  $rc .= chr(105); # i
  $rc .= chr(96); # `
  $rc .= chr(124); # |
  $rc .= chr(106); # j
  $rc .= chr(71); # G
  $rc .= chr(107); # k
  $rc .= chr(70); # F
  $rc .= chr(108); # l
  $rc .= chr(69); # E
  $rc .= chr(109); # m
  $rc .= chr(68); # D
  $rc .= chr(110); # n
  $rc .= chr(72); # H
  $rc .= chr(113); # q
  $rc .= chr(74); # J
  $rc .= chr(116); # t
  $rc .= chr(76); # L
  $rc .= chr(117); # u
  $rc .= chr(75); # K
  $rc .= chr(118); # v
  $rc .= chr(78); # N
  $rc .= chr(119); # w
  $rc .= chr(77); # M
  $rc .= chr(120); # x
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\377\\335' => '
#
# Stub version of: \\377\\335
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(221); # \\335

  return $rc;
}
',
          '\\E[%%' => '
#
# Stub version of: \\E[%%
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= \'%\';

  return $rc;
}
',
          '\\E[%}\\024' => '
#
# Stub version of: \\E[%}\\024
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(37); # %
  $rc .= chr(125); # }
  $rc .= chr(20); # \\024

  return $rc;
}
',
          '\\EO1;5P' => '
#
# Stub version of: \\EO1;5P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E?h' => '
#
# Stub version of: \\E?h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EF02' => '
#
# Stub version of: \\EF02
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\EwG\\Ee)$<100>' => '
#
# Stub version of: \\EwG\\Ee)$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(41); # )
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\177' => '
#
# Stub version of: \\E\\177
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(127); # \\177

  return $rc;
}
',
          '\\0<' => '
#
# Stub version of: \\0<
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(60); # <

  return $rc;
}
',
          '\\377\\361' => '
#
# Stub version of: \\377\\361
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(241); # \\361

  return $rc;
}
',
          '\\EFA' => '
#
# Stub version of: \\EFA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(65); # A

  return $rc;
}
',
          '^^F@' => '
#
# Stub version of: ^^F@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(70); # F
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[1*q\\E[2!t\\E[7!t\\E[=4;101;119;122l\\E[=107;118;207h\\E)1\\E[1Q\\EW\\E[!y\\E[!z\\E>\\E[0\\:0\\:32!r\\E[0*w\\E[w\\E2\\r\\n\\E[2;27!t' => '
#
# Stub version of: \\E[1*q\\E[2!t\\E[7!t\\E[=4;101;119;122l\\E[=107;118;207h\\E)1\\E[1Q\\EW\\E[!y\\E[!z\\E>\\E[0\\:0\\:32!r\\E[0*w\\E[w\\E2\\r\\n\\E[2;27!t
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(33); # !
  $rc .= chr(116); # t
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(33); # !
  $rc .= chr(116); # t
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(121); # y
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(122); # z
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\:
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\:
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(33); # !
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(33); # !
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\233J' => '
#
# Stub version of: \\233J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(74); # J

  return $rc;
}
',
          'End' => '
#
# Stub version of: End
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(69); # E
  $rc .= chr(110); # n
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\E[53;0|' => '
#
# Stub version of: \\E[53;0|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\E[14;2~' => '
#
# Stub version of: \\E[14;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E0P\\E)' => '
#
# Stub version of: \\E0P\\E)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(80); # P
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )

  return $rc;
}
',
          '\\ESD' => '
#
# Stub version of: \\ESD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\035$<4/>' => '
#
# Stub version of: \\035$<4/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EK$<200>\\Ek' => '
#
# Stub version of: \\EK$<200>\\Ek
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\E[%p1%dM$<5>' => '
#
# Stub version of: \\E[%p1%dM$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^\\\\' => '
#
# Stub version of: ^^\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\Ey\\r' => '
#
# Stub version of: \\Ey\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[=0;%i%p1%dm' => '
#
# Stub version of: \\E[=0;%i%p1%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[30;1H\\E[K\\E[30;1;0;30p' => '
#
# Stub version of: \\E[30;1H\\E[K\\E[30;1;0;30p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\Ee6\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`;\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<200>' => '
#
# Stub version of: \\Ee6\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`;\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(59); # ;
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(55); # 7
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[>1;6B' => '
#
# Stub version of: \\E[>1;6B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\EF4' => '
#
# Stub version of: \\EF4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\0[' => '
#
# Stub version of: \\0[
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(91); # [

  return $rc;
}
',
          '^A`\\r' => '
#
# Stub version of: ^A`\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(96); # `
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E!^J' => '
#
# Stub version of: \\E!^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '\\r$<100/>' => '
#
# Stub version of: \\r$<100/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EG0\\E%%%%\\E(%?%p1%p5%p8%|%|%t\\E)%;%?%p9%t\\E$%;' => '
#
# Stub version of: \\EG0\\E%%%%\\E(%?%p1%p5%p8%|%|%t\\E)%;%?%p9%t\\E$%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= \'%\';
  $rc .= \'%\';
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, $param[7]); # %p8
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(41); # )
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(36); # $
  } # %;

  return $rc;
}
',
          '\\E[1;6B' => '
#
# Stub version of: \\E[1;6B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[?1048h\\E[?1047h' => '
#
# Stub version of: \\E[?1048h\\E[?1047h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EU\\Ev  8p\\Ep\\r\\E\\025$<16>' => '
#
# Stub version of: \\EU\\Ev  8p\\Ep\\r\\E\\025$<16>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(56); # 8
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(21); # \\025
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E?q' => '
#
# Stub version of: \\E?q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\EO6S' => '
#
# Stub version of: \\EO6S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(54); # 6
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\ET$<10/>' => '
#
# Stub version of: \\ET$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E7\\E[60;0;0;60p\\E[1;1H\\E[K\\E[H\\E8\\r\\n\\E[K' => '
#
# Stub version of: \\E7\\E[60;0;0;60p\\E[1;1H\\E[K\\E[H\\E8\\r\\n\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E<\\E[=4l\\E[=8h' => '
#
# Stub version of: \\E<\\E[=4l\\E[=8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[>2l' => '
#
# Stub version of: \\E[>2l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(50); # 2
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\Ey0' => '
#
# Stub version of: \\Ey0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[C$<2>' => '
#
# Stub version of: \\E[C$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          'b\\011c\\014d\\re\\ni\\013' => '
#
# Stub version of: b\\011c\\014d\\re\\ni\\013
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(98); # b
  $rc .= chr(9); # \\011
  $rc .= chr(99); # c
  $rc .= chr(12); # \\014
  $rc .= chr(100); # d
  $rc .= chr(13); # \\r
  $rc .= chr(101); # e
  $rc .= chr(10); # \\n
  $rc .= chr(105); # i
  $rc .= chr(11); # \\013

  return $rc;
}
',
          '\\ENC' => '
#
# Stub version of: \\ENC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[?9i' => '
#
# Stub version of: \\E[?9i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(57); # 9
  $rc .= chr(105); # i

  return $rc;
}
',
          '1^Z' => '
#
# Stub version of: 1^Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(49); # 1
  $rc .= chr(0); # ^Z

  return $rc;
}
',
          '^\\020\\r' => '
#
# Stub version of: ^\\020\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(16); # \\020
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%p1%dS' => '
#
# Stub version of: \\E[%p1%dS
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\036$<5>' => '
#
# Stub version of: \\036$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO1;2R' => '
#
# Stub version of: \\EO1;2R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[?2h\\E[?3h\\E[?5l\\E[?7h\\E[?8h\\E>\\E[?1l\\E F\\E[?42l\\E[?4l' => '
#
# Stub version of: \\E[?2h\\E[?3h\\E[?5l\\E[?7h\\E[?8h\\E>\\E[?1l\\E F\\E[?42l\\E[?4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\r\\n$<6>' => '
#
# Stub version of: \\r\\n$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\001M%p2%d\\,%p1%d\\,' => '
#
# Stub version of: \\001M%p2%d\\,%p1%d\\,
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(1); # \\001
  $rc .= chr(77); # M
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(128); # \\,
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(128); # \\,

  return $rc;
}
',
          '\\E`$<650>' => '
#
# Stub version of: \\E`$<650>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '~\\023$<40>' => '
#
# Stub version of: ~\\023$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(19); # \\023
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%p1%d;%p2%l%d;1;0p   F%p1%d           %p2%s' => '
#
# Stub version of: \\E[%p1%d;%p2%l%d;1;0p   F%p1%d           %p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '8' => '
#
# Stub version of: 8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\EK\\Ea' => '
#
# Stub version of: \\EK\\Ea
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\E[60;0;0;30p\\E[30;1H\\E[K' => '
#
# Stub version of: \\E[60;0;0;30p\\E[30;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '^AG\\r' => '
#
# Stub version of: ^AG\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(71); # G
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^A4\\r' => '
#
# Stub version of: ^A4\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(52); # 4
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Eb0' => '
#
# Stub version of: \\Eb0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(48); # 0

  return $rc;
}
',
          '@$<\\233>' => '
#
# Stub version of: @$<\\233>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(64); # @
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(155); # \\233
  $rc .= chr(62); # >

  return $rc;
}
',
          '^Z7' => '
#
# Stub version of: ^Z7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Z
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\ERJ' => '
#
# Stub version of: \\ERJ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(74); # J

  return $rc;
}
',
          '^B/\\r' => '
#
# Stub version of: ^B/\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(47); # /
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[s\\E[>1h\\E[25;%i%p1%dH' => '
#
# Stub version of: \\E[s\\E[>1h\\E[25;%i%p1%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\EO1;2A' => '
#
# Stub version of: \\EO1;2A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[6;5~' => '
#
# Stub version of: \\E[6;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[p' => '
#
# Stub version of: \\E[p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\Ef5' => '
#
# Stub version of: \\Ef5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\ER$<1>' => '
#
# Stub version of: \\ER$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E>\\E[?1l\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h' => '
#
# Stub version of: \\E>\\E[?1l\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\Ec\\E[12h\\E)0' => '
#
# Stub version of: \\Ec\\E[12h\\E)0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[Y' => '
#
# Stub version of: \\E[Y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(89); # Y

  return $rc;
}
',
          '\\036A%p1%{48}%+%c' => '
#
# Stub version of: \\036A%p1%{48}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(65); # A
  push(@iparam, $param[0]); # %p1
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E&s0A' => '
#
# Stub version of: \\E&s0A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(115); # s
  $rc .= chr(48); # 0
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E&v0S\\E&d@' => '
#
# Stub version of: \\E&v0S\\E&d@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(48); # 0
  $rc .= chr(83); # S
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E`6\\E)' => '
#
# Stub version of: \\E`6\\E)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )

  return $rc;
}
',
          '\\Ev\\r' => '
#
# Stub version of: \\Ev\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[H\\E[2J$<10/>' => '
#
# Stub version of: \\E[H\\E[2J$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[6A' => '
#
# Stub version of: \\E[6A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\016A\\016\\036$<40>' => '
#
# Stub version of: \\016A\\016\\036$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  $rc .= chr(65); # A
  $rc .= chr(14); # \\016
  $rc .= chr(30); # \\036
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EG1' => '
#
# Stub version of: \\EG1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[ Q\\E[?67;8h' => '
#
# Stub version of: \\E[ Q\\E[?67;8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(32); #  
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E\\034$<40>' => '
#
# Stub version of: \\E\\034$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(28); # \\034
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\274' => '
#
# Stub version of: \\377\\274
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(188); # \\274

  return $rc;
}
',
          '\\E#<' => '
#
# Stub version of: \\E#<
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(60); # <

  return $rc;
}
',
          '\\E&jA\\r' => '
#
# Stub version of: \\E&jA\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(106); # j
  $rc .= chr(65); # A
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EcB0\\EcC1' => '
#
# Stub version of: \\EcB0\\EcC1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(66); # B
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(67); # C
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E&a%p2%dc%p1%dY$<20>' => '
#
# Stub version of: \\E&a%p2%dc%p1%dY$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(99); # c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(89); # Y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E%\\E!0\\EQD1\\EUX03\\EKA\\ELBB2\\ELCE0\\ELI100\\ELJ2\\ELLB2\\ELM0\\ELS1\\ELX00\\ELV1\\E%\\E!1\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h' => '
#
# Stub version of: \\E%\\E!0\\EQD1\\EUX03\\EKA\\ELBB2\\ELCE0\\ELI100\\ELJ2\\ELLB2\\ELM0\\ELS1\\ELX00\\ELV1\\E%\\E!1\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(68); # D
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(88); # X
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(66); # B
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(67); # C
  $rc .= chr(69); # E
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(73); # I
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(74); # J
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(77); # M
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(83); # S
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(88); # X
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(86); # V
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[%p1%d@$<4*>' => '
#
# Stub version of: \\E[%p1%d@$<4*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(64); # @
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[8;0|\\E[?\\E[13;20l\\E[?\\E[12h' => '
#
# Stub version of: \\E[8;0|\\E[?\\E[13;20l\\E[?\\E[12h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\233103z' => '
#
# Stub version of: \\233103z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[21~' => '
#
# Stub version of: \\E[21~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EH$<2/>' => '
#
# Stub version of: \\EH$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\006$<2>' => '
#
# Stub version of: \\006$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(6); # \\006
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\002%i%p1%c%p2%c' => '
#
# Stub version of: \\002%i%p1%c%p2%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(2); # \\002
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[%p1%d;%p2%l%dq%p2%s' => '
#
# Stub version of: \\E[%p1%d;%p2%l%dq%p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(113); # q
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '1' => '
#
# Stub version of: 1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p5%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%t;7%;%?%p7%t;9%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p5%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%t;7%;%?%p7%t;9%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[0]); # %p1
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(57); # 9
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\E[d' => '
#
# Stub version of: \\E[d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(100); # d

  return $rc;
}
',
          '^_@' => '
#
# Stub version of: ^_@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^_
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\027$<20*>' => '
#
# Stub version of: \\027$<20*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(23); # \\027
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E`0' => '
#
# Stub version of: \\E`0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\Ee' => '
#
# Stub version of: \\Ee
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\n$<30>' => '
#
# Stub version of: \\n$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\001$<80>' => '
#
# Stub version of: \\001$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(1); # \\001
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\037@A\\021\\n' => '
#
# Stub version of: \\037@A\\021\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(64); # @
  $rc .= chr(65); # A
  $rc .= chr(17); # \\021
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\E[1!z\\E[0;3u' => '
#
# Stub version of: \\E[1!z\\E[0;3u
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(33); # !
  $rc .= chr(122); # z
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\E[11;5~' => '
#
# Stub version of: \\E[11;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dr$<100>' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dr$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(114); # r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ENQ' => '
#
# Stub version of: \\ENQ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\017\\035\\E(B\\E)0\\E[?7l\\E[?3l\\E[>8g' => '
#
# Stub version of: \\017\\035\\E(B\\E)0\\E[?7l\\E[?3l\\E[>8g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(29); # \\035
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(56); # 8
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\377\\374' => '
#
# Stub version of: \\377\\374
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(252); # \\374

  return $rc;
}
',
          '\\E[148q' => '
#
# Stub version of: \\E[148q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\EOR' => '
#
# Stub version of: \\EOR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\Ee6\\E~%$<100>\\E+\\E`;\\Ed/\\E`1\\EO\\Ee4\\Ec@0@\\Ec@1A\\EcB0\\EcC1\\Ee7$<100>' => '
#
# Stub version of: \\Ee6\\E~%$<100>\\E+\\E`;\\Ed/\\E`1\\EO\\Ee4\\Ec@0@\\Ec@1A\\EcB0\\EcC1\\Ee7$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(37); # %
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(59); # ;
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(64); # @
  $rc .= chr(48); # 0
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(64); # @
  $rc .= chr(49); # 1
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(66); # B
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(67); # C
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(55); # 7
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E7\\E[r\\E8\\EE\\EE\\EE\\EM\\EM\\EM\\E[?7h\\E[?1l\\E[?3l\\E7\\E[1;40r\\E8' => '
#
# Stub version of: \\E7\\E[r\\E8\\EE\\EE\\EE\\EM\\EM\\EM\\E[?7h\\E[?1l\\E[?3l\\E7\\E[1;40r\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E&d@\\017' => '
#
# Stub version of: \\E&d@\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(64); # @
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '^NU' => '
#
# Stub version of: ^NU
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^N
  $rc .= chr(85); # U

  return $rc;
}
',
          '\\Es\\r' => '
#
# Stub version of: \\Es\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '$<6>' => '
#
# Stub version of: $<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[ Q' => '
#
# Stub version of: \\E[ Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(32); #  
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E[r' => '
#
# Stub version of: \\E[r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\377\\323' => '
#
# Stub version of: \\377\\323
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(211); # \\323

  return $rc;
}
',
          '^^7' => '
#
# Stub version of: ^^7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\022$<5.5*>' => '
#
# Stub version of: \\022$<5.5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(18); # \\022
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[209q' => '
#
# Stub version of: \\E[209q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\0\\0\\0\\0\\0\\036D' => '
#
# Stub version of: \\0\\0\\0\\0\\0\\036D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(30); # \\036
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\ER\\EP\\EM' => '
#
# Stub version of: \\ER\\EP\\EM
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\El\\E"\\EF1\\E.3\\016\\EA\\E<' => '
#
# Stub version of: \\El\\E"\\EF1\\E.3\\016\\EA\\E<
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(51); # 3
  $rc .= chr(14); # \\016
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(60); # <

  return $rc;
}
',
          '\\EI' => '
#
# Stub version of: \\EI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\0R' => '
#
# Stub version of: \\0R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\2330%?%p6%t;1%;%?%p2%t;4%;%?%p4%t;5%;%?%p5%t2%;%?%p7%t8%;%?%p1%p3%|%t;7%;m' => '
#
# Stub version of: \\2330%?%p6%t;1%;%?%p2%t;4%;%?%p4%t;5%;%?%p5%t2%;%?%p7%t8%;%?%p1%p3%|%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(56); # 8
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[H\\E[J$<10/>' => '
#
# Stub version of: \\E[H\\E[J$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%i%d;%dR' => '
#
# Stub version of: \\E[%i%d;%dR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\ET' => '
#
# Stub version of: \\ET
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\E[24;1H' => '
#
# Stub version of: \\E[24;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[?5l\\E[36*|\\E[36t\\E[40l\\E[1;36r\\E[132$|' => '
#
# Stub version of: \\E[?5l\\E[36*|\\E[36t\\E[40l\\E[1;36r\\E[132$|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(42); # *
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(116); # t
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\E[34;2~' => '
#
# Stub version of: \\E[34;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[0m\\E(B' => '
#
# Stub version of: \\E[0m\\E(B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B

  return $rc;
}
',
          '^_@A' => '
#
# Stub version of: ^_@A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^_
  $rc .= chr(64); # @
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[1;4F' => '
#
# Stub version of: \\E[1;4F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\EL$<1/>' => '
#
# Stub version of: \\EL$<1/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0i' => '
#
# Stub version of: \\E[0i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(105); # i

  return $rc;
}
',
          '^V^G' => '
#
# Stub version of: ^V^G
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^G

  return $rc;
}
',
          '\\002\\Ep\\003' => '
#
# Stub version of: \\002\\Ep\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(2); # \\002
  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '\\EF' => '
#
# Stub version of: \\EF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E[%?%p1%{8}%<%t3%p1%e<%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%;%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m' => '
#
# Stub version of: \\E[%?%p1%{8}%<%t3%p1%e<%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%;%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 8); # %{8}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
    push(@iparam, $param[0]); # %p1
  }
  else { # %e
    $rc .= chr(60); # <
    push(@iparam, $param[0]); # %p1
    push(@iparam, 2); # %{2}
    push(@iparam, pop(@iparam) & pop(@iparam)); # %&
    if (do { # %?
             push(@iparam, $param[0]); # %p1
             push(@iparam, 1); # %{1}
             push(@iparam, pop(@iparam) & pop(@iparam)); # %&
             pop(@iparam);
           }) { # %t
      push(@iparam, 4); # %{4}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
    if (do { # %?
             push(@iparam, $param[0]); # %p1
             push(@iparam, 4); # %{4}
             push(@iparam, pop(@iparam) & pop(@iparam)); # %&
             pop(@iparam);
           }) { # %t
      push(@iparam, 1); # %{1}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
  } # %;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  if (do { # %?
           push(@iparam, $staticp->[3]); # %gD
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[20]); # %gU
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[1]); # %gB
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[17]); # %gR
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '^J^M' => '
#
# Stub version of: ^J^M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^J
  $rc .= chr(0); # ^M

  return $rc;
}
',
          '\\E[m\\E[1;24r' => '
#
# Stub version of: \\E[m\\E[1;24r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[60;0;0;26p\\E[26;1H\\E[K' => '
#
# Stub version of: \\E[60;0;0;26p\\E[26;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\r$<162>' => '
#
# Stub version of: \\r$<162>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?3l' => '
#
# Stub version of: \\E[?3l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l

  return $rc;
}
',
          '1\\EN\\EL$<9>\\EQ \\EP$<9> \\EO\\ER\\EA' => '
#
# Stub version of: 1\\EN\\EL$<9>\\EQ \\EP$<9> \\EO\\ER\\EA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(57); # 9
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(57); # 9
  $rc .= chr(62); # >
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\Eb$<15>\\Ed' => '
#
# Stub version of: \\Eb$<15>\\Ed
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d

  return $rc;
}
',
          '^P \\0' => '
#
# Stub version of: ^P \\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(32); #  
  $rc .= chr(128); # \\0

  return $rc;
}
',
          '\\E$<20>I' => '
#
# Stub version of: \\E$<20>I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\E[002q' => '
#
# Stub version of: \\E[002q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[2m' => '
#
# Stub version of: \\E[2m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[1g' => '
#
# Stub version of: \\E[1g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(103); # g

  return $rc;
}
',
          '^V;' => '
#
# Stub version of: ^V;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\Ez%p1%{47}%+%c%p2%s\\r' => '
#
# Stub version of: \\Ez%p1%{47}%+%c%p2%s\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  push(@iparam, $param[0]); # %p1
  push(@iparam, 47); # %{47}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[?1034l' => '
#
# Stub version of: \\E[?1034l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          'F7' => '
#
# Stub version of: F7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\E[@' => '
#
# Stub version of: \\E[@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(64); # @

  return $rc;
}
',
          '^Aq' => '
#
# Stub version of: ^Aq
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\Ep%p1%d;' => '
#
# Stub version of: \\Ep%p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '^\\038\\r' => '
#
# Stub version of: ^\\038\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(128); # \\0
  $rc .= chr(51); # 3
  $rc .= chr(56); # 8
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E]%p1%{32}%+%c' => '
#
# Stub version of: \\E]%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E=$<4>' => '
#
# Stub version of: \\E=$<4>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[J' => '
#
# Stub version of: \\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\EON' => '
#
# Stub version of: \\EON
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(78); # N

  return $rc;
}
',
          '\\EQ1;' => '
#
# Stub version of: \\EQ1;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E<\\E[1;48r\\E[0q\\E[3;4q\\E=\\E[?1h' => '
#
# Stub version of: \\E<\\E[1;48r\\E[0q\\E[3;4q\\E=\\E[?1h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[%p1%d;%p2%l%d;2;0p   F%p1%d           %p2%s' => '
#
# Stub version of: \\E[%p1%d;%p2%l%d;2;0p   F%p1%d           %p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\EU\\EV' => '
#
# Stub version of: \\EU\\EV
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V

  return $rc;
}
',
          '\\E[009z' => '
#
# Stub version of: \\E[009z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[B$<5>' => '
#
# Stub version of: \\E[B$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(66); # B
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E/>1h' => '
#
# Stub version of: \\E/>1h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[>11l\\EP1**x0/11;1/13\\E[m\\E\\\\' => '
#
# Stub version of: \\E[>11l\\EP1**x0/11;1/13\\E[m\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(42); # *
  $rc .= chr(120); # x
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(47); # /
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\EO1;4P' => '
#
# Stub version of: \\EO1;4P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[255;1p\\E[255;1H\\E[K' => '
#
# Stub version of: \\E[255;1p\\E[255;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E|%p1%{49}%+%c%p2%s\\031' => '
#
# Stub version of: \\E|%p1%{49}%+%c%p2%s\\031
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(124); # |
  push(@iparam, $param[0]); # %p1
  push(@iparam, 49); # %{49}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(25); # \\031

  return $rc;
}
',
          '\\n$<3>' => '
#
# Stub version of: \\n$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '^V^E' => '
#
# Stub version of: ^V^E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^E

  return $rc;
}
',
          '\\E[0%?%p1%p3%|%t;7%;m%?%p9%t\\E(0%e\\E(B%;$<5>' => '
#
# Stub version of: \\E[0%?%p1%p3%|%t;7%;m%?%p9%t\\E(0%e\\E(B%;$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '^Ay\\r' => '
#
# Stub version of: ^Ay\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(121); # y
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[?8i' => '
#
# Stub version of: \\E[?8i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E[%p1%dE' => '
#
# Stub version of: \\E[%p1%dE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\23333~' => '
#
# Stub version of: \\23333~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^V^A\\0' => '
#
# Stub version of: ^V^A\\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^A
  $rc .= chr(128); # \\0

  return $rc;
}
',
          '\\r\\n\\E[A\\E7\\E[255;1;0;33;80;80p\\E8\\E[J' => '
#
# Stub version of: \\r\\n\\E[A\\E7\\E[255;1;0;33;80;80p\\E8\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\233312z' => '
#
# Stub version of: \\233312z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[?7l\\E[?1l\\E(B' => '
#
# Stub version of: \\E[?7l\\E[?1l\\E(B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E|%{48}%p1%+%c1%p2\\031' => '
#
# Stub version of: \\E|%{48}%p1%+%c1%p2\\031
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(124); # |
  push(@iparam, 48); # %{48}
  push(@iparam, $param[0]); # %p1
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(49); # 1
  push(@iparam, $param[1]); # %p2
  $rc .= chr(25); # \\031

  return $rc;
}
',
          '\\E[4;0;2;1;1;1v\\E(B\\E)4' => '
#
# Stub version of: \\E[4;0;2;1;1;1v\\E(B\\E)4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\EDF\\EC\\Ed\\EG0\\Eg\\Er\\EO\\E\'\\E(\\E%\\Ew\\EX\\Ee \\017\\011\\El\\E016\\E004\\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\011\\Ex3\\0\\0\\Ex4\\r\\0\\Ef\\r' => '
#
# Stub version of: \\EDF\\EC\\Ed\\EG0\\Eg\\Er\\EO\\E\'\\E(\\E%\\Ew\\EX\\Ee \\017\\011\\El\\E016\\E004\\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\011\\Ex3\\0\\0\\Ex4\\r\\0\\Ef\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(32); #  
  $rc .= chr(15); # \\017
  $rc .= chr(9); # \\011
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(9); # \\011
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(52); # 4
  $rc .= chr(13); # \\r
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%p1%dM$<1*/>' => '
#
# Stub version of: \\E[%p1%dM$<1*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EBI' => '
#
# Stub version of: \\EBI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(66); # B
  $rc .= chr(73); # I

  return $rc;
}
',
          'green' => '
#
# Stub version of: green
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(103); # g
  $rc .= chr(114); # r
  $rc .= chr(101); # e
  $rc .= chr(101); # e
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\E[1$}\\E[2$~' => '
#
# Stub version of: \\E[1$}\\E[2$~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(125); # }
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EO1;5D' => '
#
# Stub version of: \\EO1;5D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(68); # D

  return $rc;
}
',
          '^Ai\\r' => '
#
# Stub version of: ^Ai\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(105); # i
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^^*' => '
#
# Stub version of: ^^*
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(42); # *

  return $rc;
}
',
          '\\E=%p1%{32}%+%c%p2%{32}%+%c$<3/>' => '
#
# Stub version of: \\E=%p1%{32}%+%c%p2%{32}%+%c$<3/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[r\\E[m\\E[2J\\E[H\\E[?7h\\E[?1;3;4;6l\\E[4l\\E>' => '
#
# Stub version of: \\E[r\\E[m\\E[2J\\E[H\\E[?7h\\E[?1;3;4;6l\\E[4l\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\351' => '
#
# Stub version of: \\377\\351
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(233); # \\351

  return $rc;
}
',
          '\\E[022z' => '
#
# Stub version of: \\E[022z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\036Ad\\036Bd' => '
#
# Stub version of: \\036Ad\\036Bd
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(65); # A
  $rc .= chr(100); # d
  $rc .= chr(30); # \\036
  $rc .= chr(66); # B
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\E[19\\^' => '
#
# Stub version of: \\E[19\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\EE$<1>' => '
#
# Stub version of: \\EE$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EFs' => '
#
# Stub version of: \\EFs
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\377\\201' => '
#
# Stub version of: \\377\\201
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(129); # \\201

  return $rc;
}
',
          '\\EK$<2>' => '
#
# Stub version of: \\EK$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E%!0\\ETFB000001F4F4F42F40030F404A4C<F450F4F46F40F47F4F40\\E%!1' => '
#
# Stub version of: \\E%!0\\ETFB000001F4F4F42F40030F404A4C<F450F4F46F40F47F4F40\\E%!1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(70); # F
  $rc .= chr(66); # B
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(65); # A
  $rc .= chr(52); # 4
  $rc .= chr(67); # C
  $rc .= chr(60); # <
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(54); # 6
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[%p1%dM$<2*>' => '
#
# Stub version of: \\E[%p1%dM$<2*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1;3D' => '
#
# Stub version of: \\E[1;3D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\EP$<10>' => '
#
# Stub version of: \\EP$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?12l\\E[?25h' => '
#
# Stub version of: \\E[?12l\\E[?25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\027$<40>' => '
#
# Stub version of: \\027$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(23); # \\027
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[61"p\\E[40h\\E[?6l\\E[1r\\E[2;3;4;13;20;34;39;36l\\E[12;16;34h\\E[?1;3;4;5;10;18l\\E[?7;8;25h\\E>\\E[?5W\\E(B\\017\\E[24E\\E[4i' => '
#
# Stub version of: \\E[61"p\\E[40h\\E[?6l\\E[1r\\E[2;3;4;13;20;34;39;36l\\E[12;16;34h\\E[?1;3;4;5;10;18l\\E[?7;8;25h\\E>\\E[?5W\\E(B\\017\\E[24E\\E[4i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(49); # 1
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(87); # W
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E;3' => '
#
# Stub version of: \\E;3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[19;0j' => '
#
# Stub version of: \\E[19;0j
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j

  return $rc;
}
',
          '\\EF\\Ef2;' => '
#
# Stub version of: \\EF\\Ef2;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\EQ\\r' => '
#
# Stub version of: \\EQ\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[8;0|\\E[?4;5;13;15l\\E[13;20l\\E[?3;7h\\E[12h\\E(B\\E)0' => '
#
# Stub version of: \\E[8;0|\\E[?4;5;13;15l\\E[13;20l\\E[?3;7h\\E[12h\\E(B\\E)0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E>B' => '
#
# Stub version of: \\E>B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[m$<2/>' => '
#
# Stub version of: \\E[m$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t30;40%;m' => '
#
# Stub version of: \\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t30;40%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
    $rc .= chr(48); # 0
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
    $rc .= chr(48); # 0
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Ef!' => '
#
# Stub version of: \\Ef!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\233 p' => '
#
# Stub version of: \\233 p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(32); #  
  $rc .= chr(112); # p

  return $rc;
}
',
          '^D' => '
#
# Stub version of: ^D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^D

  return $rc;
}
',
          '^V^P' => '
#
# Stub version of: ^V^P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^P

  return $rc;
}
',
          '\\E\\^' => '
#
# Stub version of: \\E\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\s^H' => '
#
# Stub version of: \\s^H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(32); # \\s
  $rc .= chr(0); # ^H

  return $rc;
}
',
          '\\E7\\E[r\\E[m\\E[?7h\\E[?1;4;6l\\E[4l\\E8\\E>\\E]R' => '
#
# Stub version of: \\E7\\E[r\\E[m\\E[?7h\\E[?1;4;6l\\E[4l\\E8\\E>\\E]R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[1@' => '
#
# Stub version of: \\E[1@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[2 D' => '
#
# Stub version of: \\E[2 D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(32); #  
  $rc .= chr(68); # D

  return $rc;
}
',
          'white' => '
#
# Stub version of: white
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(119); # w
  $rc .= chr(104); # h
  $rc .= chr(105); # i
  $rc .= chr(116); # t
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\E[3;6~' => '
#
# Stub version of: \\E[3;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E<\\E[?21l\\E[19h\\E[1Q\\E[10l\\E[7l\\E[H\\E[2J' => '
#
# Stub version of: \\E<\\E[?21l\\E[19h\\E[1Q\\E[10l\\E[7l\\E[H\\E[2J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[011z' => '
#
# Stub version of: \\E[011z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '^^m' => '
#
# Stub version of: ^^m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[=1C' => '
#
# Stub version of: \\E[=1C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E~>\\E8' => '
#
# Stub version of: \\E~>\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '^A0\\r' => '
#
# Stub version of: ^A0\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(48); # 0
  $rc .= chr(13); # \\r

  return $rc;
}
',
          'A on-line' => '
#
# Stub version of: A on-line
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(65); # A
  $rc .= chr(32); #  
  $rc .= chr(111); # o
  $rc .= chr(110); # n
  $rc .= chr(45); # -
  $rc .= chr(108); # l
  $rc .= chr(105); # i
  $rc .= chr(110); # n
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m%?%p9%t\\016%e\\017%;$<100>' => '
#
# Stub version of: \\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m%?%p9%t\\016%e\\017%;$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E]s\\n\\E]W' => '
#
# Stub version of: \\E]s\\n\\E]W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(115); # s
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\E[197z' => '
#
# Stub version of: \\E[197z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(55); # 7
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E7\\E[25;%p1%{1}%+%dH' => '
#
# Stub version of: \\E7\\E[25;%p1%{1}%+%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  push(@iparam, 1); # %{1}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\EFh' => '
#
# Stub version of: \\EFh
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[2i' => '
#
# Stub version of: \\E[2i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E\\023\\E!' => '
#
# Stub version of: \\E\\023\\E!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  $rc .= chr(27); # \\E
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\n$<5000/>' => '
#
# Stub version of: \\n$<5000/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO$<5.5*>' => '
#
# Stub version of: \\EO$<5.5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0V\\E8' => '
#
# Stub version of: \\E[0V\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(86); # V
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\EO1;3S' => '
#
# Stub version of: \\EO1;3S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E[5@' => '
#
# Stub version of: \\E[5@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E*$<300/>' => '
#
# Stub version of: \\E*$<300/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\n\\0\\0\\0\\n\\0\\0\\0\\EA\\EK\\0\\0\\0\\ET\\ET' => '
#
# Stub version of: \\n\\0\\0\\0\\n\\0\\0\\0\\EA\\EK\\0\\0\\0\\ET\\ET
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(10); # \\n
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(27); # \\E
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\E^S' => '
#
# Stub version of: \\E^S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^S

  return $rc;
}
',
          '\\E[4r' => '
#
# Stub version of: \\E[4r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\EJ$<2>' => '
#
# Stub version of: \\EJ$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0;23r\\Ex\\Ey\\E[2;0j\\E[3;3j\\E[4;0j\\E[5;1j\\E[6;0j\\E[7;0j\\E[8;0j\\E[9;1j\\E[10;0j\\E[15;0j\\E[16;1j\\E[19;0j\\E[20;1j\\E[29;0j\\E[1;24r' => '
#
# Stub version of: \\E[0;23r\\Ex\\Ey\\E[2;0j\\E[3;3j\\E[4;0j\\E[5;1j\\E[6;0j\\E[7;0j\\E[8;0j\\E[9;1j\\E[10;0j\\E[15;0j\\E[16;1j\\E[19;0j\\E[20;1j\\E[29;0j\\E[1;24r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E$2\\004' => '
#
# Stub version of: \\E$2\\004
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(50); # 2
  $rc .= chr(4); # \\004

  return $rc;
}
',
          '\\E[1;1!w' => '
#
# Stub version of: \\E[1;1!w
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(33); # !
  $rc .= chr(119); # w

  return $rc;
}
',
          'PF1' => '
#
# Stub version of: PF1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(80); # P
  $rc .= chr(70); # F
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\Ej$<5>' => '
#
# Stub version of: \\Ej$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ES\\E#\\E*\\Eh\\Em\\E?\\E1\\E9\\E@\\EX\\EU\\E"*Z01\\E"8F35021B7C83#\\E"8F45021B7D83#\\E"8F55021B7E83#\\E"8F65021B7F83#\\E"8F75021B7383#\\E"8F851BD7#\\E"8F95021B7083#\\E"8FA5021B7183#\\E"8FB5021B7283#' => '
#
# Stub version of: \\ES\\E#\\E*\\Eh\\Em\\E?\\E1\\E9\\E@\\EX\\EU\\E"*Z01\\E"8F35021B7C83#\\E"8F45021B7D83#\\E"8F55021B7E83#\\E"8F65021B7F83#\\E"8F75021B7383#\\E"8F851BD7#\\E"8F95021B7083#\\E"8FA5021B7183#\\E"8FB5021B7283#
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(42); # *
  $rc .= chr(90); # Z
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(56); # 8
  $rc .= chr(70); # F
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(66); # B
  $rc .= chr(55); # 7
  $rc .= chr(67); # C
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(35); # #
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(56); # 8
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(66); # B
  $rc .= chr(55); # 7
  $rc .= chr(68); # D
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(35); # #
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(56); # 8
  $rc .= chr(70); # F
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(66); # B
  $rc .= chr(55); # 7
  $rc .= chr(69); # E
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(35); # #
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(56); # 8
  $rc .= chr(70); # F
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(66); # B
  $rc .= chr(55); # 7
  $rc .= chr(70); # F
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(35); # #
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(56); # 8
  $rc .= chr(70); # F
  $rc .= chr(55); # 7
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(66); # B
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(35); # #
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(56); # 8
  $rc .= chr(70); # F
  $rc .= chr(56); # 8
  $rc .= chr(53); # 5
  $rc .= chr(49); # 1
  $rc .= chr(66); # B
  $rc .= chr(68); # D
  $rc .= chr(55); # 7
  $rc .= chr(35); # #
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(56); # 8
  $rc .= chr(70); # F
  $rc .= chr(57); # 9
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(66); # B
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(35); # #
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(56); # 8
  $rc .= chr(70); # F
  $rc .= chr(65); # A
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(66); # B
  $rc .= chr(55); # 7
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(35); # #
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(56); # 8
  $rc .= chr(70); # F
  $rc .= chr(66); # B
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(66); # B
  $rc .= chr(55); # 7
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(35); # #

  return $rc;
}
',
          '\\E[12m' => '
#
# Stub version of: \\E[12m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(109); # m

  return $rc;
}
',
          '^\\047\\r' => '
#
# Stub version of: ^\\047\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(39); # \\047
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Ec@1J$<2000>' => '
#
# Stub version of: \\Ec@1J$<2000>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(64); # @
  $rc .= chr(49); # 1
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ec21' => '
#
# Stub version of: \\Ec21
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\377\\306' => '
#
# Stub version of: \\377\\306
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(198); # \\306

  return $rc;
}
',
          '\\2333%p1%dm' => '
#
# Stub version of: \\2333%p1%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EP1;1|%?%{16}%p1%>%t%{0}%e%{21}%p1%>%t%{1}%e%{25}%p1%>%t%{2}%e%{27}%p1%>%t%{3}%e%{30}%p1%>%t%{4}%e%{5}%;%p1%+%d/%p2%s\\E\\\\' => '
#
# Stub version of: \\EP1;1|%?%{16}%p1%>%t%{0}%e%{21}%p1%>%t%{1}%e%{25}%p1%>%t%{2}%e%{27}%p1%>%t%{3}%e%{30}%p1%>%t%{4}%e%{5}%;%p1%+%d/%p2%s\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |
  if (do { # %?
           push(@iparam, 16); # %{16}
           push(@iparam, $param[0]); # %p1
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, 0); # %{0}
  }
  elsif (do { # %e
              push(@iparam, 21); # %{21}
              push(@iparam, $param[0]); # %p1
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
              pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
  }
  elsif (do { # %e
              push(@iparam, 25); # %{25}
              push(@iparam, $param[0]); # %p1
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
              pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
  }
  elsif (do { # %e
              push(@iparam, 27); # %{27}
              push(@iparam, $param[0]); # %p1
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
              pop(@iparam);
         }) { # %t
    push(@iparam, 3); # %{3}
  }
  elsif (do { # %e
              push(@iparam, 30); # %{30}
              push(@iparam, $param[0]); # %p1
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
              pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
  }
  else { # %e
    push(@iparam, 5); # %{5}
  } # %;
  push(@iparam, $param[0]); # %p1
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(47); # /
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E 1$<16*>' => '
#
# Stub version of: \\E 1$<16*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[4i\\E[?4i' => '
#
# Stub version of: \\E[4i\\E[?4i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(105); # i
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E_3' => '
#
# Stub version of: \\E_3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\233313z' => '
#
# Stub version of: \\233313z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          'e' => '
#
# Stub version of: e
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(101); # e

  return $rc;
}
',
          '\\E[?3h$<100>' => '
#
# Stub version of: \\E[?3h$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E^J' => '
#
# Stub version of: \\E^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '\\0\\210' => '
#
# Stub version of: \\0\\210
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(136); # \\210

  return $rc;
}
',
          '\\E[14~' => '
#
# Stub version of: \\E[14~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '$<.1*/>' => '
#
# Stub version of: $<.1*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(46); # .
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\243' => '
#
# Stub version of: \\243
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(163); # \\243

  return $rc;
}
',
          '\\233000z' => '
#
# Stub version of: \\233000z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\022\\003\\036P@1' => '
#
# Stub version of: \\022\\003\\036P@1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(18); # \\022
  $rc .= chr(3); # \\003
  $rc .= chr(30); # \\036
  $rc .= chr(80); # P
  $rc .= chr(64); # @
  $rc .= chr(49); # 1

  return $rc;
}
',
          '^^Pf' => '
#
# Stub version of: ^^Pf
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\E[E' => '
#
# Stub version of: \\E[E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\EO1;5C' => '
#
# Stub version of: \\EO1;5C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\EOd' => '
#
# Stub version of: \\EOd
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\037wor 33h' => '
#
# Stub version of: \\037wor 33h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(119); # w
  $rc .= chr(111); # o
  $rc .= chr(114); # r
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[J$<10/>' => '
#
# Stub version of: \\E[J$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&bn\\E&bB\\E&bG\\E&bR%{0}%PX%{0}%PY%{0}%PZ%{1}%PW%{1}%PV%{1}%PU' => '
#
# Stub version of: \\E&bn\\E&bB\\E&bG\\E&bR%{0}%PX%{0}%PY%{0}%PZ%{1}%PW%{1}%PV%{1}%PU
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(98); # b
  $rc .= chr(110); # n
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(98); # b
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(98); # b
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(98); # b
  $rc .= chr(82); # R
  push(@iparam, 0); # %{0}
  $staticp->[23] = pop(@iparam); # %PX
  push(@iparam, 0); # %{0}
  $staticp->[24] = pop(@iparam); # %PY
  push(@iparam, 0); # %{0}
  $staticp->[25] = pop(@iparam); # %PZ
  push(@iparam, 1); # %{1}
  $staticp->[22] = pop(@iparam); # %PW
  push(@iparam, 1); # %{1}
  $staticp->[21] = pop(@iparam); # %PV
  push(@iparam, 1); # %{1}
  $staticp->[20] = pop(@iparam); # %PU

  return $rc;
}
',
          '\\E[%p1%d;0u#%p2%s#' => '
#
# Stub version of: \\E[%p1%d;0u#%p2%s#
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(117); # u
  $rc .= chr(35); # #
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(35); # #

  return $rc;
}
',
          '+.\\,\\,./f0g1' => '
#
# Stub version of: +.\\,\\,./f0g1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(46); # .
  $rc .= chr(128); # \\,
  $rc .= chr(128); # \\,
  $rc .= chr(46); # .
  $rc .= chr(47); # /
  $rc .= chr(102); # f
  $rc .= chr(48); # 0
  $rc .= chr(103); # g
  $rc .= chr(49); # 1

  return $rc;
}
',
          '%{0}%?%p4%t%{2}%|%;%?%p7%t%{1}%|%;%PA\\EG%?%gC%t%gC%e%{0}%?%p1%t%{4}%|%;%?%p2%t%{8}%|%;%?%p3%t%{4}%|%;%?%p5%t%{64}%|%;%;%gA%+%{48}%+%c%?%p8%t\\E)%e\\E(%;%?%p9%t\\EH\\002%e\\EH\\003%;' => '
#
# Stub version of: %{0}%?%p4%t%{2}%|%;%?%p7%t%{1}%|%;%PA\\EG%?%gC%t%gC%e%{0}%?%p1%t%{4}%|%;%?%p2%t%{8}%|%;%?%p3%t%{4}%|%;%?%p5%t%{64}%|%;%;%gA%+%{48}%+%c%?%p8%t\\E)%e\\E(%;%?%p9%t\\EH\\002%e\\EH\\003%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  push(@iparam, 0); # %{0}
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $staticp->[0] = pop(@iparam); # %PA
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  if (do { # %?
           push(@iparam, $staticp->[2]); # %gC
           pop(@iparam);
         }) { # %t
    push(@iparam, $staticp->[2]); # %gC
  }
  else { # %e
    push(@iparam, 0); # %{0}
    if (do { # %?
             push(@iparam, $param[0]); # %p1
             pop(@iparam);
           }) { # %t
      push(@iparam, 4); # %{4}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
    if (do { # %?
             push(@iparam, $param[1]); # %p2
             pop(@iparam);
           }) { # %t
      push(@iparam, 8); # %{8}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
    if (do { # %?
             push(@iparam, $param[2]); # %p3
             pop(@iparam);
           }) { # %t
      push(@iparam, 4); # %{4}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
    if (do { # %?
             push(@iparam, $param[4]); # %p5
             pop(@iparam);
           }) { # %t
      push(@iparam, 64); # %{64}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
  } # %;
  push(@iparam, $staticp->[0]); # %gA
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  if (do { # %?
           push(@iparam, $param[7]); # %p8
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(41); # )
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(72); # H
    $rc .= chr(2); # \\002
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(72); # H
    $rc .= chr(3); # \\003
  } # %;

  return $rc;
}
',
          '\\E[48;1H' => '
#
# Stub version of: \\E[48;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\ET\\EG0\\010' => '
#
# Stub version of: \\ET\\EG0\\010
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(8); # \\010

  return $rc;
}
',
          '\\E(B\\017\\E[r\\E[m\\E[2J\\E[H\\E[?7h\\E[?1;3;4;6l\\E[4l\\E<' => '
#
# Stub version of: \\E(B\\017\\E[r\\E[m\\E[2J\\E[H\\E[?7h\\E[?1;3;4;6l\\E[4l\\E<
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(60); # <

  return $rc;
}
',
          '\\ET\\r' => '
#
# Stub version of: \\ET\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '$<2/>' => '
#
# Stub version of: $<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E0P' => '
#
# Stub version of: \\E0P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E=7\\s' => '
#
# Stub version of: \\E=7\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(55); # 7
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E1;2u' => '
#
# Stub version of: \\E1;2u
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\Ee+$<150>' => '
#
# Stub version of: \\Ee+$<150>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(43); # +
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?47l\\E=\\E[?1l' => '
#
# Stub version of: \\E[?47l\\E=\\E[?1l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\Ew@%p1%{48}%+%c%p2%{32}%+%c%p3%{32}%+%c$<20>' => '
#
# Stub version of: \\Ew@%p1%{48}%+%c%p2%{32}%+%c%p3%{32}%+%c$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(64); # @
  push(@iparam, $param[0]); # %p1
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[2]); # %p3
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EG1@A\\EH' => '
#
# Stub version of: \\EG1@A\\EH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(49); # 1
  $rc .= chr(64); # @
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[7r' => '
#
# Stub version of: \\E[7r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(114); # r

  return $rc;
}
',
          '^M' => '
#
# Stub version of: ^M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^M

  return $rc;
}
',
          '\\E0B' => '
#
# Stub version of: \\E0B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\377\\240' => '
#
# Stub version of: \\377\\240
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(160); # \\240

  return $rc;
}
',
          '\\E[3p' => '
#
# Stub version of: \\E[3p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E&f0a%p1%dk0d%p2%l%dL%p2%s' => '
#
# Stub version of: \\E&f0a%p1%dk0d%p2%l%dL%p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(102); # f
  $rc .= chr(48); # 0
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(107); # k
  $rc .= chr(48); # 0
  $rc .= chr(100); # d
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\E[%p1%dp' => '
#
# Stub version of: \\E[%p1%dp
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(112); # p

  return $rc;
}
',
          '^B7^J' => '
#
# Stub version of: ^B7^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(55); # 7
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '\\036F}00\\036FP%p1%2.2X18\\036PG' => '
#
# Stub version of: \\036F}00\\036FP%p1%2.2X18\\036PG
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(125); # }
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(80); # P
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(30); # \\036
  $rc .= chr(80); # P
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\EF00' => '
#
# Stub version of: \\EF00
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '^B3^J' => '
#
# Stub version of: ^B3^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(51); # 3
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '\\E[1K' => '
#
# Stub version of: \\E[1K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\2330Q' => '
#
# Stub version of: \\2330Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(81); # Q

  return $rc;
}
',
          '+SRCH' => '
#
# Stub version of: +SRCH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(83); # S
  $rc .= chr(82); # R
  $rc .= chr(67); # C
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\233%p1%dL' => '
#
# Stub version of: \\233%p1%dL
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L

  return $rc;
}
',
          '^\\048\\r' => '
#
# Stub version of: ^\\048\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(128); # \\0
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\ER$<1*/>' => '
#
# Stub version of: \\ER$<1*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E_d' => '
#
# Stub version of: \\E_d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\EO1;7B' => '
#
# Stub version of: \\EO1;7B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[211z' => '
#
# Stub version of: \\E[211z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[1~' => '
#
# Stub version of: \\E[1~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E%!0' => '
#
# Stub version of: \\E%!0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\EN$<1*/>' => '
#
# Stub version of: \\EN$<1*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[02s' => '
#
# Stub version of: \\E[02s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E[?2h\\E[?3h\\E[?5h\\E[?7h\\E[?8h\\E>\\E[?1l\\E G\\E[?42l\\E[?4l' => '
#
# Stub version of: \\E[?2h\\E[?3h\\E[?5h\\E[?7h\\E[?8h\\E>\\E[?1l\\E G\\E[?42l\\E[?4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[?38l\\E)0' => '
#
# Stub version of: \\E[?38l\\E)0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(56); # 8
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[23s' => '
#
# Stub version of: \\E[23s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\EGp' => '
#
# Stub version of: \\EGp
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[2$' => '
#
# Stub version of: \\E[2$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\E>\\E[?5h\\E[?7h' => '
#
# Stub version of: \\E>\\E[?5h\\E[?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\0`' => '
#
# Stub version of: \\0`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(96); # `

  return $rc;
}
',
          '\\EE$<2*/>' => '
#
# Stub version of: \\EE$<2*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EP\\r' => '
#
# Stub version of: \\EP\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Ej$<2>' => '
#
# Stub version of: \\Ej$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\n$<8>' => '
#
# Stub version of: \\n$<8>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\245' => '
#
# Stub version of: \\245
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(165); # \\245

  return $rc;
}
',
          '\\036F}10' => '
#
# Stub version of: \\036F}10
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(125); # }
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E]P%p1%x%p2%{255}%*%{1000}%/%02x%p3%{255}%*%{1000}%/%02x%p4%{255}%*%{1000}%/%02x' => '
#
# Stub version of: \\E]P%p1%x%p2%{255}%*%{1000}%/%02x%p3%{255}%*%{1000}%/%02x%p4%{255}%*%{1000}%/%02x
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(80); # P
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%x\', pop(@iparam)); # %x
  push(@iparam, $param[1]); # %p2
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= sprintf(\'%02x\', pop(@iparam)); # %02x
  push(@iparam, $param[2]); # %p3
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= sprintf(\'%02x\', pop(@iparam)); # %02x
  push(@iparam, $param[3]); # %p4
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= sprintf(\'%02x\', pop(@iparam)); # %02x

  return $rc;
}
',
          '\\037up\\r\\037ili %p1%d\\r' => '
#
# Stub version of: \\037up\\r\\037ili %p1%d\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(117); # u
  $rc .= chr(112); # p
  $rc .= chr(13); # \\r
  $rc .= chr(31); # \\037
  $rc .= chr(105); # i
  $rc .= chr(108); # l
  $rc .= chr(105); # i
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%p1%d;%p2%l%02d;0;0q%p3%:-16.16s%p2%s' => '
#
# Stub version of: \\E[%p1%d;%p2%l%02d;0;0q%p3%:-16.16s%p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%02d\', pop(@iparam)); # %02d
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(113); # q
  push(@iparam, $param[2]); # %p3
  $rc .= sprintf(\'%-16.16s\', pop(@iparam)); # %-16.16s
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\EAC' => '
#
# Stub version of: \\EAC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E0%p1%{33}%+%c%p2%{33}%+%c' => '
#
# Stub version of: \\E0%p1%{33}%+%c%p2%{33}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  push(@iparam, $param[0]); # %p1
  push(@iparam, 33); # %{33}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 33); # %{33}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[?7h\\E[>\\E[?1l\\E F\\E[?4l' => '
#
# Stub version of: \\E[?7h\\E[>\\E[?1l\\E F\\E[?4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\377\\256' => '
#
# Stub version of: \\377\\256
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(174); # \\256

  return $rc;
}
',
          '\\EA10' => '
#
# Stub version of: \\EA10
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\EPr\\\\E[0u\\E[2J\\E[0;0H\\E[m\\E[3l\\E[<l\\E[4l\\E[>l\\E[=l\\E[?l' => '
#
# Stub version of: \\EPr\\\\E[0u\\E[2J\\E[0;0H\\E[m\\E[3l\\E[<l\\E[4l\\E[>l\\E[=l\\E[?l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(114); # r
  $rc .= chr(92); # \\
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E<\\E["p\\E[50;6"p\\Ec\\E[?3l\\E]R\\E[?1000l' => '
#
# Stub version of: \\E<\\E["p\\E[50;6"p\\Ec\\E[?3l\\E]R\\E[?1000l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(82); # R
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\Ey$<3*/>' => '
#
# Stub version of: \\Ey$<3*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO2P' => '
#
# Stub version of: \\EO2P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(50); # 2
  $rc .= chr(80); # P

  return $rc;
}
',
          '^^l' => '
#
# Stub version of: ^^l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[3;3~' => '
#
# Stub version of: \\E[3;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[4m$<30>' => '
#
# Stub version of: \\E[4m$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%p1%dL$<1*/>' => '
#
# Stub version of: \\E[%p1%dL$<1*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[60;1;0;30p\\E[59;1H\\E[K' => '
#
# Stub version of: \\E[60;1;0;30p\\E[59;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E[0%?%p1%p3%|%t;7%;%?%p2%t;4%;%?%p4%t;5%;%?%p6%t;1%;m%?%p8%t\\E[32%%{%;%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p1%p3%|%t;7%;%?%p2%t;4%;%?%p4%t;5%;%?%p6%t;1%;m%?%p8%t\\E[32%%{%;%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[7]); # %p8
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(51); # 3
    $rc .= chr(50); # 2
    $rc .= \'%\';
    $rc .= chr(123); # {
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\E1%p2%{32}%+%c%p1%{32}%+%c' => '
#
# Stub version of: \\E1%p2%{32}%+%c%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[209z' => '
#
# Stub version of: \\E[209z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\Eq\\Ek\\Em\\EA\\Ex0' => '
#
# Stub version of: \\Eq\\Ek\\Em\\EA\\Ex0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[0;98v' => '
#
# Stub version of: \\E[0;98v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(118); # v

  return $rc;
}
',
          '^^^K' => '
#
# Stub version of: ^^^K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(0); # ^K

  return $rc;
}
',
          '\\Ej$<10>' => '
#
# Stub version of: \\Ej$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Eo$<200/>\\En' => '
#
# Stub version of: \\Eo$<200/>\\En
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(111); # o
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\011$<2>' => '
#
# Stub version of: \\011$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(9); # \\011
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EOu' => '
#
# Stub version of: \\EOu
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\Ei6' => '
#
# Stub version of: \\Ei6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(105); # i
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E;$<1>' => '
#
# Stub version of: \\E;$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(59); # ;
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EB' => '
#
# Stub version of: \\EB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\Ej\\EYI \\EI\\Ek' => '
#
# Stub version of: \\Ej\\EYI \\EI\\Ek
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(73); # I
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\E[4l\\E[0Q' => '
#
# Stub version of: \\E[4l\\E[0Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(81); # Q

  return $rc;
}
',
          '^S' => '
#
# Stub version of: ^S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^S

  return $rc;
}
',
          '\\EC\\r' => '
#
# Stub version of: \\EC\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[12h\\E[?10l\\E%/0n\\E[P\\031\\E[?3h\\E(B\\E)0$<200>' => '
#
# Stub version of: \\E[12h\\E[?10l\\E%/0n\\E[P\\031\\E[?3h\\E(B\\E)0$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= chr(48); # 0
  $rc .= chr(110); # n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(80); # P
  $rc .= chr(25); # \\031
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          'aaffggjjkkllmmnnooqqssttuuvvwwxx' => '
#
# Stub version of: aaffggjjkkllmmnnooqqssttuuvvwwxx
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\0\\207' => '
#
# Stub version of: \\0\\207
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(135); # \\207

  return $rc;
}
',
          '\\E[0%?%p1%t;2;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p1%t;2;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\ESU' => '
#
# Stub version of: \\ESU
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(85); # U

  return $rc;
}
',
          '\\E[%p1%d;%p2%dH' => '
#
# Stub version of: \\E[%p1%d;%p2%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\EO' => '
#
# Stub version of: \\EO
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\E[?5h' => '
#
# Stub version of: \\E[?5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[0;10%?%p1%t;7%;%?%p2%t;1%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;11%;m' => '
#
# Stub version of: \\E[0;10%?%p1%t;7%;%?%p2%t;1%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;11%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\ER\\E0P\\EV' => '
#
# Stub version of: \\ER\\E0P\\EV
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(80); # P
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V

  return $rc;
}
',
          '^^I' => '
#
# Stub version of: ^^I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;12%;m' => '
#
# Stub version of: \\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;12%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(50); # 2
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[234z' => '
#
# Stub version of: \\E[234z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E(0' => '
#
# Stub version of: \\E(0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E@\\r' => '
#
# Stub version of: \\E@\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(64); # @
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[302z' => '
#
# Stub version of: \\E[302z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[1;2C' => '
#
# Stub version of: \\E[1;2C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\Eu\\Ee6\\EC\\EDF\\Ec21\\Ec31\\Ec62\\Ec72\\Ee;\\016\\E\'\\EeL\\E`9\\E\\^0\\E`1\\E`4\\Ee.\\E`\\:\\Ee1\\EG0\\E(\\Ed/\\Ee4\\Ed*\\EO\\E`I\\Er\\Ee"\\EcD\\024' => '
#
# Stub version of: \\Eu\\Ee6\\EC\\EDF\\Ec21\\Ec31\\Ec62\\Ec72\\Ee;\\016\\E\'\\EeL\\E`9\\E\\^0\\E`1\\E`4\\Ee.\\E`\\:\\Ee1\\EG0\\E(\\Ed/\\Ee4\\Ed*\\EO\\E`I\\Er\\Ee"\\EcD\\024
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(54); # 6
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(55); # 7
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(59); # ;
  $rc .= chr(14); # \\016
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(76); # L
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(46); # .
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(68); # D
  $rc .= chr(20); # \\024

  return $rc;
}
',
          '\\E\\023\\E8' => '
#
# Stub version of: \\E\\023\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E0%p5%{64}%+%p4%{2}%*%+%p3%{16}%*%+%p2%{32}%*%+%p1%{17}%*%+%c\\016' => '
#
# Stub version of: \\E0%p5%{64}%+%p4%{2}%*%+%p3%{16}%*%+%p2%{32}%*%+%p1%{17}%*%+%c\\016
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  push(@iparam, $param[4]); # %p5
  push(@iparam, 64); # %{64}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, $param[3]); # %p4
  push(@iparam, 2); # %{2}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, $param[2]); # %p3
  push(@iparam, 16); # %{16}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, $param[0]); # %p1
  push(@iparam, 17); # %{17}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(14); # \\016

  return $rc;
}
',
          '\\EVE' => '
#
# Stub version of: \\EVE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\E[?5l$<200/>\\E[?5h' => '
#
# Stub version of: \\E[?5l$<200/>\\E[?5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E\\023\\E3' => '
#
# Stub version of: \\E\\023\\E3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3

  return $rc;
}
',
          '^S\\E^Q' => '
#
# Stub version of: ^S\\E^Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^S
  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^Q

  return $rc;
}
',
          '\\E&a%p1%dC$<6/>' => '
#
# Stub version of: \\E&a%p1%dC$<6/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[;71;0;71p\\E[;72;0;72p\\E[;73;0;73p\\E[;77;0;77p\\E[;80;0;80p\\E[;81;0;81p\\E[;82;0;82p\\E[;83;0;83p' => '
#
# Stub version of: \\E[;71;0;71p\\E[;72;0;72p\\E[;73;0;73p\\E[;77;0;77p\\E[;80;0;80p\\E[;81;0;81p\\E[;82;0;82p\\E[;83;0;83p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(49); # 1
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(50); # 2
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(55); # 7
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(49); # 1
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(50); # 2
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[0K$<3>' => '
#
# Stub version of: \\E[0K$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[11t' => '
#
# Stub version of: \\E[11t
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\Ee*$<150>' => '
#
# Stub version of: \\Ee*$<150>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(42); # *
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ee!' => '
#
# Stub version of: \\Ee!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dr$<20>' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dr$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(114); # r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[2$~\\E[1$}\\E[1;%dH' => '
#
# Stub version of: \\E[2$~\\E[1$}\\E[1;%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(126); # ~
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(125); # }
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[4;1v\\E_30' => '
#
# Stub version of: \\E[4;1v\\E_30
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0

  return $rc;
}
',
          'f3' => '
#
# Stub version of: f3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(102); # f
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[29;0|' => '
#
# Stub version of: \\E[29;0|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\E[H\\E[2J$<80>' => '
#
# Stub version of: \\E[H\\E[2J$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ed$<10*/>' => '
#
# Stub version of: \\Ed$<10*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '++\\,\\,--..00``aaffgghhjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~' => '
#
# Stub version of: ++\\,\\,--..00``aaffgghhjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(43); # +
  $rc .= chr(128); # \\,
  $rc .= chr(128); # \\,
  $rc .= chr(45); # -
  $rc .= chr(45); # -
  $rc .= chr(46); # .
  $rc .= chr(46); # .
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(104); # h
  $rc .= chr(104); # h
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(121); # y
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(123); # {
  $rc .= chr(123); # {
  $rc .= chr(124); # |
  $rc .= chr(124); # |
  $rc .= chr(125); # }
  $rc .= chr(125); # }
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[>1l\\E[>9h' => '
#
# Stub version of: \\E[>1l\\E[>9h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(57); # 9
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[%d;%dR' => '
#
# Stub version of: \\E[%d;%dR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[231z' => '
#
# Stub version of: \\E[231z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EO1;3R' => '
#
# Stub version of: \\EO1;3R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\Ee$<1*>' => '
#
# Stub version of: \\Ee$<1*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[R' => '
#
# Stub version of: \\E[R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E\\EE' => '
#
# Stub version of: \\E\\EE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\013%p1%\' \'%+%c\\020%p2%{10}%/%{16}%*%p2%{10}%m%+%c' => '
#
# Stub version of: \\013%p1%\' \'%+%c\\020%p2%{10}%/%{16}%*%p2%{10}%m%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  push(@iparam, $param[0]); # %p1
  push(@iparam, chr(32)); # %\' \'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(16); # \\020
  push(@iparam, $param[1]); # %p2
  push(@iparam, 10); # %{10}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 16); # %{16}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, $param[1]); # %p2
  push(@iparam, 10); # %{10}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E7\\E1;24r\\E[?6l\\E[25;%i%p1%dH' => '
#
# Stub version of: \\E7\\E1;24r\\E[?6l\\E[25;%i%p1%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          'F16' => '
#
# Stub version of: F16
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E[24\\^' => '
#
# Stub version of: \\E[24\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\EwJ\\Ew1$<150>' => '
#
# Stub version of: \\EwJ\\Ew1$<150>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\020\\021%p2%c%p1%c' => '
#
# Stub version of: \\020\\021%p2%c%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  $rc .= chr(17); # \\021
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[<0;<1;<2;<4l\\E[5;0v\\E[1;1;80w\\E[1;6;<2h' => '
#
# Stub version of: \\E[<0;<1;<2;<4l\\E[5;0v\\E[1;1;80w\\E[1;6;<2h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '^]^C' => '
#
# Stub version of: ^]^C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^]
  $rc .= chr(0); # ^C

  return $rc;
}
',
          '\\E[23~' => '
#
# Stub version of: \\E[23~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[60;0;0;40p\\E[40;1H\\E[K' => '
#
# Stub version of: \\E[60;0;0;40p\\E[40;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '^]\\s' => '
#
# Stub version of: ^]\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^]
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E`2\\E`1' => '
#
# Stub version of: \\E`2\\E`1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1

  return $rc;
}
',
          '~^K' => '
#
# Stub version of: ~^K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(0); # ^K

  return $rc;
}
',
          '\\E[w' => '
#
# Stub version of: \\E[w
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(119); # w

  return $rc;
}
',
          'S$<\\217>' => '
#
# Stub version of: S$<\\217>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(83); # S
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(143); # \\217
  $rc .= chr(62); # >

  return $rc;
}
',
          '^\\010\\r' => '
#
# Stub version of: ^\\010\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(8); # \\010
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Ek' => '
#
# Stub version of: \\Ek
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\E&v%p2%da%p3%db%p4%dc%p5%dx%p6%dy%p7%dz%p1%dI' => '
#
# Stub version of: \\E&v%p2%da%p3%db%p4%dc%p5%dx%p6%dy%p7%dz%p1%dI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(97); # a
  push(@iparam, $param[2]); # %p3
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(98); # b
  push(@iparam, $param[3]); # %p4
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(99); # c
  push(@iparam, $param[4]); # %p5
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(120); # x
  push(@iparam, $param[5]); # %p6
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(121); # y
  push(@iparam, $param[6]); # %p7
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(122); # z
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(73); # I

  return $rc;
}
',
          '^^n' => '
#
# Stub version of: ^^n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\EW$<10>' => '
#
# Stub version of: \\EW$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1K\\E[X' => '
#
# Stub version of: \\E[1K\\E[X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(88); # X

  return $rc;
}
',
          '++\\,\\,--..00II``aaffgghhjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~' => '
#
# Stub version of: ++\\,\\,--..00II``aaffgghhjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(43); # +
  $rc .= chr(128); # \\,
  $rc .= chr(128); # \\,
  $rc .= chr(45); # -
  $rc .= chr(45); # -
  $rc .= chr(46); # .
  $rc .= chr(46); # .
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(73); # I
  $rc .= chr(73); # I
  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(104); # h
  $rc .= chr(104); # h
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(121); # y
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(123); # {
  $rc .= chr(123); # {
  $rc .= chr(124); # |
  $rc .= chr(124); # |
  $rc .= chr(125); # }
  $rc .= chr(125); # }
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[0;37;44m' => '
#
# Stub version of: \\E[0;37;44m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[1u\\027' => '
#
# Stub version of: \\E[1u\\027
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(23); # \\027

  return $rc;
}
',
          '\\2336~' => '
#
# Stub version of: \\2336~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\233?12;25h' => '
#
# Stub version of: \\233?12;25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E%!1\\E[<0m$<2>\\E%!0' => '
#
# Stub version of: \\E%!1\\E[<0m$<2>\\E%!0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E7\\E[r\\E8\\E[m\\E[?7h\\E[!p\\E[?1;3;4;6l\\E[4l\\E>\\E[?1000l\\E[?25h' => '
#
# Stub version of: \\E7\\E[r\\E8\\E[m\\E[?7h\\E[!p\\E[?1;3;4;6l\\E[4l\\E>\\E[?1000l\\E[?25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\020%p1%{10}%/%{16}%*%p1%{10}%m%+%Pc%?%{17}%gc%=%{19}%gc%=%|%gc%!%|%t%{1}%gc%+%c%{8}%e%gc%;%c' => '
#
# Stub version of: \\020%p1%{10}%/%{16}%*%p1%{10}%m%+%Pc%?%{17}%gc%=%{19}%gc%=%|%gc%!%|%t%{1}%gc%+%c%{8}%e%gc%;%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  push(@iparam, $param[0]); # %p1
  push(@iparam, 10); # %{10}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 16); # %{16}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, $param[0]); # %p1
  push(@iparam, 10); # %{10}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $dynamicp->[2] = pop(@iparam); # %Pc
  if (do { # %?
           push(@iparam, 17); # %{17}
           push(@iparam, $dynamicp->[2]); # %gc
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           push(@iparam, 19); # %{19}
           push(@iparam, $dynamicp->[2]); # %gc
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $dynamicp->[2]); # %gc
           push(@iparam, ! pop(@iparam)); # %!
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, $dynamicp->[2]); # %gc
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
    push(@iparam, 8); # %{8}
  }
  else { # %e
    push(@iparam, $dynamicp->[2]); # %gc
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\036FB%?%p1%t%p1%2.2X0%;%p2%p1%-%{1}%+%2.2X0%?%{23}%p2%>%t%{23}%p2%-%2.2X0%;000\\036FX%p3%2.2X%p4%2.2X' => '
#
# Stub version of: \\036FB%?%p1%t%p1%2.2X0%;%p2%p1%-%{1}%+%2.2X0%?%{23}%p2%>%t%{23}%p2%-%2.2X0%;000\\036FX%p3%2.2X%p4%2.2X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(66); # B
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
    $rc .= chr(48); # 0
  } # %;
  push(@iparam, $param[1]); # %p2
  push(@iparam, $param[0]); # %p1
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  push(@iparam, 1); # %{1}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, 23); # %{23}
           push(@iparam, $param[1]); # %p2
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, 23); # %{23}
    push(@iparam, $param[1]); # %p2
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
    $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
    $rc .= chr(48); # 0
  } # %;
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(88); # X
  push(@iparam, $param[2]); # %p3
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  push(@iparam, $param[3]); # %p4
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X

  return $rc;
}
',
          '^Am\\r' => '
#
# Stub version of: ^Am\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(109); # m
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^^"' => '
#
# Stub version of: ^^"
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(34); # "

  return $rc;
}
',
          '\\E[003z' => '
#
# Stub version of: \\E[003z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[10m' => '
#
# Stub version of: \\E[10m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EFK' => '
#
# Stub version of: \\EFK
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E[6u\\027' => '
#
# Stub version of: \\E[6u\\027
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(117); # u
  $rc .= chr(23); # \\027

  return $rc;
}
',
          '\\217w' => '
#
# Stub version of: \\217w
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\E[20l' => '
#
# Stub version of: \\E[20l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\r\\035rig %p1%d;' => '
#
# Stub version of: \\r\\035rig %p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(29); # \\035
  $rc .= chr(114); # r
  $rc .= chr(105); # i
  $rc .= chr(103); # g
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\036FQ5\\036FW\\036FK\\036F\\^\\036FX0083\\036O\\036FS00' => '
#
# Stub version of: \\036FQ5\\036FW\\036FK\\036F\\^\\036FX0083\\036O\\036FS00
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(81); # Q
  $rc .= chr(53); # 5
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(87); # W
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(75); # K
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(128); # \\^
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(88); # X
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(30); # \\036
  $rc .= chr(79); # O
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\ER%p1%d;' => '
#
# Stub version of: \\ER%p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dR' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\Ez_\\Eb@\\EcA' => '
#
# Stub version of: \\Ez_\\Eb@\\EcA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(95); # _
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\011%p2%\'\\0\'%+%c%p1%\'\\0\'%+%c' => '
#
# Stub version of: \\011%p2%\'\\0\'%+%c%p1%\'\\0\'%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(9); # \\011
  push(@iparam, $param[1]); # %p2
  push(@iparam, chr(128)); # %\'\\0\'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, chr(128)); # %\'\\0\'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\EOO' => '
#
# Stub version of: \\EOO
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\036N\\036FS0E\\036O\\036FS00' => '
#
# Stub version of: \\036N\\036FS0E\\036O\\036FS00
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(78); # N
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  $rc .= chr(48); # 0
  $rc .= chr(69); # E
  $rc .= chr(30); # \\036
  $rc .= chr(79); # O
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\036%?%p1%p3%|%p6%|%tD%eE%;%?%p2%p6%|%t\\024%e\\025%;%?%p4%t\\016%e\\017%;%?%p1%p5%|%t\\034%e\\035%;\\036%?%p9%tN%eO%;' => '
#
# Stub version of: \\036%?%p1%p3%|%p6%|%tD%eE%;%?%p2%p6%|%t\\024%e\\025%;%?%p4%t\\016%e\\017%;%?%p1%p5%|%t\\034%e\\035%;\\036%?%p9%tN%eO%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(68); # D
  }
  else { # %e
    $rc .= chr(69); # E
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(20); # \\024
  }
  else { # %e
    $rc .= chr(21); # \\025
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(28); # \\034
  }
  else { # %e
    $rc .= chr(29); # \\035
  } # %;
  $rc .= chr(30); # \\036
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(78); # N
  }
  else { # %e
    $rc .= chr(79); # O
  } # %;

  return $rc;
}
',
          '\\EH$<3>' => '
#
# Stub version of: \\EH$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '2' => '
#
# Stub version of: 2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\2331A' => '
#
# Stub version of: \\2331A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E/>6l' => '
#
# Stub version of: \\E/>6l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(54); # 6
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\Em' => '
#
# Stub version of: \\Em
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\233S' => '
#
# Stub version of: \\233S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\EFz' => '
#
# Stub version of: \\EFz
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[35h\\E[?3l$<70>' => '
#
# Stub version of: \\E[35h\\E[?3l$<70>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E;' => '
#
# Stub version of: \\E;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(59); # ;

  return $rc;
}
',
          '^No' => '
#
# Stub version of: ^No
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^N
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\014$<100/>' => '
#
# Stub version of: \\014$<100/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[18;5~' => '
#
# Stub version of: \\E[18;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\2334%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m' => '
#
# Stub version of: \\2334%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(52); # 4
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[7$' => '
#
# Stub version of: \\E[7$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(36); # $

  return $rc;
}
',
          '^^P' => '
#
# Stub version of: ^^P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\EC$<2/>' => '
#
# Stub version of: \\EC$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^^Y' => '
#
# Stub version of: ^^^Y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(0); # ^Y

  return $rc;
}
',
          '\\E[7;2m' => '
#
# Stub version of: \\E[7;2m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\2331S' => '
#
# Stub version of: \\2331S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\r$<1000>' => '
#
# Stub version of: \\r$<1000>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EY%p1%{32}%+%c%p2%{32}%+%c$<20>' => '
#
# Stub version of: \\EY%p1%{32}%+%c%p2%{32}%+%c$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[20;5~' => '
#
# Stub version of: \\E[20;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^]\\343' => '
#
# Stub version of: ^]\\343
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^]
  $rc .= chr(227); # \\343

  return $rc;
}
',
          '\\E[48H' => '
#
# Stub version of: \\E[48H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\EY\\EF \\011' => '
#
# Stub version of: \\EY\\EF \\011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(32); #  
  $rc .= chr(9); # \\011

  return $rc;
}
',
          '\\E[92;52"p' => '
#
# Stub version of: \\E[92;52"p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(50); # 2
  $rc .= chr(34); # "
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E~E' => '
#
# Stub version of: \\E~E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\002\\E|\\003' => '
#
# Stub version of: \\002\\E|\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(2); # \\002
  $rc .= chr(27); # \\E
  $rc .= chr(124); # |
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '\\E[>?2;18l\\E[>?26;?6;20;>?15;?7;>?22;>?8h' => '
#
# Stub version of: \\E[>?2;18l\\E[>?26;?6;20;>?15;?7;>?22;>?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(62); # >
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(62); # >
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(62); # >
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[010z' => '
#
# Stub version of: \\E[010z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;m$<2>' => '
#
# Stub version of: \\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;m$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\r\\n\\E[A\\E7\\E[60;1;0;30p\\E8' => '
#
# Stub version of: \\r\\n\\E[A\\E7\\E[60;1;0;30p\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\013%p2%c%p1%c' => '
#
# Stub version of: \\013%p2%c%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[=%p1%dg' => '
#
# Stub version of: \\E[=%p1%dg
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\EF07' => '
#
# Stub version of: \\EF07
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\E[ p' => '
#
# Stub version of: \\E[ p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(32); #  
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E_0' => '
#
# Stub version of: \\E_0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\EM$<4>' => '
#
# Stub version of: \\EM$<4>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E. \\Ee' => '
#
# Stub version of: \\E. \\Ee
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\E[%?%p1%p3%|%p6%|%t7;%;%?%p4%t5;%;%?%p2%p6%|%t4;%;%?%p1%p5%|%t2;%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[%?%p1%p3%|%p6%|%t7;%;%?%p4%t5;%;%?%p2%p6%|%t4;%;%?%p1%p5%|%t2;%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '^\\IP' => '
#
# Stub version of: ^\\IP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(92); # \\
  $rc .= chr(73); # I
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[20~' => '
#
# Stub version of: \\E[20~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\233?5l$<50>\\233?5h' => '
#
# Stub version of: \\233?5l$<50>\\233?5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\177$<10*/>' => '
#
# Stub version of: \\177$<10*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(127); # \\177
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[>7l' => '
#
# Stub version of: \\E[>7l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(55); # 7
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\011$<5/>' => '
#
# Stub version of: \\011$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(9); # \\011
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[35h\\E[?3l$<8>' => '
#
# Stub version of: \\E[35h\\E[?3l$<8>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&v%p1%dS' => '
#
# Stub version of: \\E&v%p1%dS
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\036FQ2\\036FW\\036FJ\\036F\\^\\036FX004?\\036F]\\036O\\036FS00' => '
#
# Stub version of: \\036FQ2\\036FW\\036FJ\\036F\\^\\036FX004?\\036F]\\036O\\036FS00
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(81); # Q
  $rc .= chr(50); # 2
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(87); # W
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(74); # J
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(128); # \\^
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(88); # X
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(63); # ?
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(93); # ]
  $rc .= chr(30); # \\036
  $rc .= chr(79); # O
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\376H' => '
#
# Stub version of: \\376H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(254); # \\376
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\377\\235' => '
#
# Stub version of: \\377\\235
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(157); # \\235

  return $rc;
}
',
          '\\E\\^9;0s\\E\\^7;1s' => '
#
# Stub version of: \\E\\^9;0s\\E\\^7;1s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E[?1049h' => '
#
# Stub version of: \\E[?1049h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\23329~' => '
#
# Stub version of: \\23329~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[%p2%db%p1%c' => '
#
# Stub version of: \\E[%p2%db%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(98); # b
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\002%^M' => '
#
# Stub version of: \\002%^M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(2); # \\002
  push(@iparam, pop(@iparam) ^ pop(@iparam)); # %^
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\E&d@' => '
#
# Stub version of: \\E&d@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[008q' => '
#
# Stub version of: \\E[008q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E4@\\E>B' => '
#
# Stub version of: \\E4@\\E>B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[154q' => '
#
# Stub version of: \\E[154q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(52); # 4
  $rc .= chr(113); # q

  return $rc;
}
',
          '^Z6' => '
#
# Stub version of: ^Z6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Z
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\036FQ5' => '
#
# Stub version of: \\036FQ5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(81); # Q
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E!V' => '
#
# Stub version of: \\E!V
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(86); # V

  return $rc;
}
',
          '^Y^Z' => '
#
# Stub version of: ^Y^Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Y
  $rc .= chr(0); # ^Z

  return $rc;
}
',
          '^B6\\r' => '
#
# Stub version of: ^B6\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(54); # 6
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E\\Ea' => '
#
# Stub version of: \\E\\Ea
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(27); # \\E
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\E!\\0\\EW  7o\\Egf\\ES7\\s' => '
#
# Stub version of: \\E!\\0\\EW  7o\\Egf\\ES7\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(55); # 7
  $rc .= chr(111); # o
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(102); # f
  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(55); # 7
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E7\\E[255;0;0;76;178;255p\\E8\\E[J' => '
#
# Stub version of: \\E7\\E[255;0;0;76;178;255p\\E8\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\020\\035$<20>' => '
#
# Stub version of: \\020\\035$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  $rc .= chr(29); # \\035
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^B!' => '
#
# Stub version of: ^B!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\E\\023$<40>' => '
#
# Stub version of: \\E\\023$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E`7\\E)' => '
#
# Stub version of: \\E`7\\E)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )

  return $rc;
}
',
          '\\E=7h' => '
#
# Stub version of: \\E=7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EO\\Eq\\EG\\EvK6' => '
#
# Stub version of: \\EO\\Eq\\EG\\EvK6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(75); # K
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E[44"p\\E[?7h\\E[>10h\\E[>12h\\EP1;1|3/7F\\E\\\\' => '
#
# Stub version of: \\E[44"p\\E[?7h\\E[>10h\\E[>12h\\EP1;1|3/7F\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |
  $rc .= chr(51); # 3
  $rc .= chr(47); # /
  $rc .= chr(55); # 7
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E[21;5~' => '
#
# Stub version of: \\E[21;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\Ei3' => '
#
# Stub version of: \\Ei3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(105); # i
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\ENn' => '
#
# Stub version of: \\ENn
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\E[!p\\E[?3;7;19;67h\\E[?4l\\E(B\\E)0\\017\\E[2J\\E[1;1H$<200>' => '
#
# Stub version of: \\E[!p\\E[?3;7;19;67h\\E[?4l\\E(B\\E)0\\017\\E[2J\\E[1;1H$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[6;2~' => '
#
# Stub version of: \\E[6;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\023%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\023%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(19); # \\023
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\EFB' => '
#
# Stub version of: \\EFB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\036FB%?%p1%t%p1%2.2X0%;%p2%p1%-%{1}%+%2.2X0%?%{23}%p2%>%t000%;' => '
#
# Stub version of: \\036FB%?%p1%t%p1%2.2X0%;%p2%p1%-%{1}%+%2.2X0%?%{23}%p2%>%t000%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(66); # B
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
    $rc .= chr(48); # 0
  } # %;
  push(@iparam, $param[1]); # %p2
  push(@iparam, $param[0]); # %p1
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  push(@iparam, 1); # %{1}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, 23); # %{23}
           push(@iparam, $param[1]); # %p2
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
    $rc .= chr(48); # 0
    $rc .= chr(48); # 0
  } # %;

  return $rc;
}
',
          '\\E[60;0;0;20p\\E[60;1H\\E[K' => '
#
# Stub version of: \\E[60;0;0;20p\\E[60;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E[12;2~' => '
#
# Stub version of: \\E[12;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[m\\017$<2>' => '
#
# Stub version of: \\E[m\\017$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(15); # \\017
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E#D' => '
#
# Stub version of: \\E#D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\Ex\\r' => '
#
# Stub version of: \\Ex\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E)0\\017' => '
#
# Stub version of: \\E)0\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\EOi' => '
#
# Stub version of: \\EOi
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E\\003\\E5' => '
#
# Stub version of: \\E\\003\\E5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E[217q' => '
#
# Stub version of: \\E[217q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[x\\E[m\\Ec' => '
#
# Stub version of: \\E[x\\E[m\\Ec
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(120); # x
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c

  return $rc;
}
',
          '^\\017\\r' => '
#
# Stub version of: ^\\017\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(15); # \\017
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EO+\\s' => '
#
# Stub version of: \\EO+\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(43); # +
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\EOY' => '
#
# Stub version of: \\EOY
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(89); # Y

  return $rc;
}
',
          '\\Ey$<2*>$<10>' => '
#
# Stub version of: \\Ey$<2*>$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(62); # >
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E>\\E[0;7m\\014' => '
#
# Stub version of: \\E>\\E[0;7m\\014
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(12); # \\014

  return $rc;
}
',
          '\\EDF\\EC\\EG0\\Er\\E(\\E%\\EX\\En4' => '
#
# Stub version of: \\EDF\\EC\\EG0\\Er\\E(\\E%\\EX\\En4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(110); # n
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\2331m' => '
#
# Stub version of: \\2331m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Eb^D' => '
#
# Stub version of: \\Eb^D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(0); # ^D

  return $rc;
}
',
          '\\E[=40h\\E[?3l' => '
#
# Stub version of: \\E[=40h\\E[?3l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E>\\E[?1;3;4;5;6l\\E[4l\\E[?7h\\E[m\\E[r\\E[2J\\E[H' => '
#
# Stub version of: \\E>\\E[?1;3;4;5;6l\\E[4l\\E[?7h\\E[m\\E[r\\E[2J\\E[H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H

  return $rc;
}
',
          '^V^A^G' => '
#
# Stub version of: ^V^A^G
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^A
  $rc .= chr(0); # ^G

  return $rc;
}
',
          '\\E[%?%p1%{0}%=%t40m%e%p1%{1}%=%t41m%e%p1%{2}%=%t42m%e%p1%{3}%=%t43m%e%p1%{4}%=%t44m%e%p1%{5}%=%t45m%e%p1%{6}%=%t46m%e%p1%{7}%=%t107m%;' => '
#
# Stub version of: \\E[%?%p1%{0}%=%t40m%e%p1%{1}%=%t41m%e%p1%{2}%=%t42m%e%p1%{3}%=%t43m%e%p1%{4}%=%t44m%e%p1%{5}%=%t45m%e%p1%{6}%=%t46m%e%p1%{7}%=%t107m%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(48); # 0
    $rc .= chr(109); # m
  } # %;
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 1); # %{1}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(49); # 1
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 2); # %{2}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(50); # 2
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(51); # 3
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(52); # 4
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 5); # %{5}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(53); # 5
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(54); # 6
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 7); # %{7}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
    $rc .= chr(48); # 0
    $rc .= chr(55); # 7
    $rc .= chr(109); # m
  }

  return $rc;
}
',
          '\\E\\E[m\\E[?7h\\E[?1;4l' => '
#
# Stub version of: \\E\\E[m\\E[?7h\\E[?1;4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '^^w' => '
#
# Stub version of: ^^w
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\016A\\035$<3.5>' => '
#
# Stub version of: \\016A\\035$<3.5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  $rc .= chr(65); # A
  $rc .= chr(29); # \\035
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?98l\\E[?4i' => '
#
# Stub version of: \\E[?98l\\E[?4i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E[11;0j' => '
#
# Stub version of: \\E[11;0j
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j

  return $rc;
}
',
          '\\Eb%?%p1%{0}%=%t?%e%p1%{7}%=%t0%e%p1%{15}%=%t7%e%p1%{48}%+%c' => '
#
# Stub version of: \\Eb%?%p1%{0}%=%t?%e%p1%{7}%=%t0%e%p1%{15}%=%t7%e%p1%{48}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(63); # ?
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 7); # %{7}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 15); # %{15}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    push(@iparam, 48); # %{48}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  } # ,
  return $rc;
}
',
          '\\E[1;6A' => '
#
# Stub version of: \\E[1;6A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[217z' => '
#
# Stub version of: \\E[217z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\2371\\234' => '
#
# Stub version of: \\2371\\234
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(159); # \\237
  $rc .= chr(49); # 1
  $rc .= chr(156); # \\234

  return $rc;
}
',
          '\\E[=0c' => '
#
# Stub version of: \\E[=0c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(48); # 0
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E8%i%p1%3d%p2%3d' => '
#
# Stub version of: \\E8%i%p1%3d%p2%3d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%3d\', pop(@iparam)); # %3d
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%3d\', pop(@iparam)); # %3d

  return $rc;
}
',
          '\\ENJ' => '
#
# Stub version of: \\ENJ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\EG\\,' => '
#
# Stub version of: \\EG\\,
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(128); # \\,

  return $rc;
}
',
          '\\E#1' => '
#
# Stub version of: \\E#1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E7\\E[?6l\\E[2K\\E[;%i%df' => '
#
# Stub version of: \\E7\\E[?6l\\E[2K\\E[;%i%df
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\E[255p\\E[255;1H\\E[K' => '
#
# Stub version of: \\E[255p\\E[255;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\EO1;4D' => '
#
# Stub version of: \\EO1;4D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\Ej\\Ex5\\Ex1\\EY8%p1%{32}%+%c\\Eo' => '
#
# Stub version of: \\Ej\\Ex5\\Ex1\\EY8%p1%{32}%+%c\\Eo
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(53); # 5
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(56); # 8
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(27); # \\E
  $rc .= chr(111); # o

  return $rc;
}
',
          '%?%p1%t\\E]%;%?%p3%t\\E]%;%?%p4%t\\EH%;' => '
#
# Stub version of: %?%p1%t\\E]%;%?%p3%t\\E]%;%?%p4%t\\EH%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(93); # ]
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(93); # ]
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(72); # H
  } # %;

  return $rc;
}
',
          '\\E\\022$<3*>' => '
#
# Stub version of: \\E\\022$<3*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(18); # \\022
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[J$<50>' => '
#
# Stub version of: \\E[J$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E001' => '
#
# Stub version of: \\E001
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E\\003\\E6' => '
#
# Stub version of: \\E\\003\\E6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\030$<40>' => '
#
# Stub version of: \\030$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(24); # \\030
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\001\\E!' => '
#
# Stub version of: \\E\\001\\E!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(33); # !

  return $rc;
}
',
          'a\\177j$k"l!m#n)q+t\'u&v(w%x*' => '
#
# Stub version of: a\\177j$k"l!m#n)q+t\'u&v(w%x*
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(97); # a
  $rc .= chr(127); # \\177
  $rc .= chr(106); # j
  $rc .= chr(36); # $
  $rc .= chr(107); # k
  $rc .= chr(34); # "
  $rc .= chr(108); # l
  $rc .= chr(33); # !
  $rc .= chr(109); # m
  $rc .= chr(35); # #
  $rc .= chr(110); # n
  $rc .= chr(41); # )
  $rc .= chr(113); # q
  $rc .= chr(43); # +
  $rc .= chr(116); # t
  $rc .= chr(39); # \'
  $rc .= chr(117); # u
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(40); # (
  $rc .= chr(119); # w
  $rc .= sprintf(\'%x\', pop(@iparam)); # %x
  $rc .= chr(42); # *

  return $rc;
}
',
          '^VG\\r' => '
#
# Stub version of: ^VG\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(71); # G
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[3;4~' => '
#
# Stub version of: \\E[3;4~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[4;1v' => '
#
# Stub version of: \\E[4;1v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\EM\\Ec' => '
#
# Stub version of: \\EM\\Ec
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E#M' => '
#
# Stub version of: \\E#M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\E[o' => '
#
# Stub version of: \\E[o
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\EOQ' => '
#
# Stub version of: \\EOQ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E5s' => '
#
# Stub version of: \\E5s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(53); # 5
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\EL$<2*>' => '
#
# Stub version of: \\EL$<2*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '^Ob' => '
#
# Stub version of: ^Ob
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^O
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E%p1%dX' => '
#
# Stub version of: \\E%p1%dX
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(88); # X

  return $rc;
}
',
          'A insert line' => '
#
# Stub version of: A insert line
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(65); # A
  $rc .= chr(32); #  
  $rc .= chr(105); # i
  $rc .= chr(110); # n
  $rc .= chr(115); # s
  $rc .= chr(101); # e
  $rc .= chr(114); # r
  $rc .= chr(116); # t
  $rc .= chr(32); #  
  $rc .= chr(108); # l
  $rc .= chr(105); # i
  $rc .= chr(110); # n
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\E(009\\,017\\,025\\,033\\,041\\,049\\,057\\,065\\,073.' => '
#
# Stub version of: \\E(009\\,017\\,025\\,033\\,041\\,049\\,057\\,065\\,073.
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(55); # 7
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(46); # .

  return $rc;
}
',
          '\\035$<10/>' => '
#
# Stub version of: \\035$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EF9' => '
#
# Stub version of: \\EF9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(57); # 9

  return $rc;
}
',
          '^B)\\r' => '
#
# Stub version of: ^B)\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(41); # )
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EJ$<1>' => '
#
# Stub version of: \\EJ$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^e' => '
#
# Stub version of: ^^e
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\EN@' => '
#
# Stub version of: \\EN@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\377\\322' => '
#
# Stub version of: \\377\\322
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(210); # \\322

  return $rc;
}
',
          'F17' => '
#
# Stub version of: F17
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\E[%p1%d@' => '
#
# Stub version of: \\E[%p1%d@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[5;7m' => '
#
# Stub version of: \\E[5;7m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[q' => '
#
# Stub version of: \\E[q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\Ed' => '
#
# Stub version of: \\Ed
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\E[!p\\E[?7;19;67h\\E[?1;3;4l\\E(B\\E)0\\017\\E[2J\\E[1;1H\\E>$<200>' => '
#
# Stub version of: \\E[!p\\E[?7;19;67h\\E[?1;3;4l\\E(B\\E)0\\017\\E[2J\\E[1;1H\\E>$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E=%p1%c%p2%c' => '
#
# Stub version of: \\E=%p1%c%p2%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\233208z' => '
#
# Stub version of: \\233208z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[196z' => '
#
# Stub version of: \\E[196z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(54); # 6
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[%p1%dL$<2*>' => '
#
# Stub version of: \\E[%p1%dL$<2*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[2@' => '
#
# Stub version of: \\E[2@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\EM\\E[?1000l' => '
#
# Stub version of: \\EM\\E[?1000l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EM$<1/>' => '
#
# Stub version of: \\EM$<1/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[6B' => '
#
# Stub version of: \\E[6B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[%i%p1%03d%p2%03df' => '
#
# Stub version of: \\E[%i%p1%03d%p2%03df
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%03d\', pop(@iparam)); # %03d
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%03d\', pop(@iparam)); # %03d
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m' => '
#
# Stub version of: \\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 8); # %{8}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 16); # %{16}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(57); # 9
    push(@iparam, $param[0]); # %p1
    push(@iparam, 8); # %{8}
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  }
  else { # %e
    $rc .= chr(51); # 3
    $rc .= chr(56); # 8
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EDC' => '
#
# Stub version of: \\EDC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[28~' => '
#
# Stub version of: \\E[28~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E$D' => '
#
# Stub version of: \\E$D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\EH\\E2$<80>' => '
#
# Stub version of: \\EH\\E2$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E)6' => '
#
# Stub version of: \\E)6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E&jB$<8>' => '
#
# Stub version of: \\E&jB$<8>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(106); # j
  $rc .= chr(66); # B
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%p1%d;0;0;1q%p2%:-16.16s' => '
#
# Stub version of: \\E[%p1%d;0;0;1q%p2%:-16.16s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(113); # q
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%-16.16s\', pop(@iparam)); # %-16.16s

  return $rc;
}
',
          '\\E[2;4;20;30l\\E[?1;4;10;16l\\E[12h\\E[?7;8;25h$<16>' => '
#
# Stub version of: \\E[2;4;20;30l\\E[?1;4;10;16l\\E[12h\\E[?7;8;25h$<16>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^6' => '
#
# Stub version of: ^^6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\EO1;3P' => '
#
# Stub version of: \\EO1;3P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E/0t' => '
#
# Stub version of: \\E/0t
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(47); # /
  $rc .= chr(48); # 0
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\377\\227' => '
#
# Stub version of: \\377\\227
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(151); # \\227

  return $rc;
}
',
          '\\EF01' => '
#
# Stub version of: \\EF01
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E*$<100>' => '
#
# Stub version of: \\E*$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ey' => '
#
# Stub version of: \\Ey
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y

  return $rc;
}
',
          '%p1%c\\022%p2%{63}%+%c' => '
#
# Stub version of: %p1%c\\022%p2%{63}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(18); # \\022
  push(@iparam, $param[1]); # %p2
  push(@iparam, 63); # %{63}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\EFX' => '
#
# Stub version of: \\EFX
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(88); # X

  return $rc;
}
',
          '\\Ec\\r' => '
#
# Stub version of: \\Ec\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\031\\030\\002\\003\\017' => '
#
# Stub version of: \\031\\030\\002\\003\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(25); # \\031
  $rc .= chr(24); # \\030
  $rc .= chr(2); # \\002
  $rc .= chr(3); # \\003
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\EG4' => '
#
# Stub version of: \\EG4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\E[?1l\\E[?4l\\E[?7l' => '
#
# Stub version of: \\E[?1l\\E[?4l\\E[?7l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[?5l$<200>\\E[?5h' => '
#
# Stub version of: \\E[?5l$<200>\\E[?5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[2J\\E[0;0H' => '
#
# Stub version of: \\E[2J\\E[0;0H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\EN\\EL$<3>\\EQ                                                                                \\EP$<3> \\EO\\ER\\EA$<3>' => '
#
# Stub version of: \\EN\\EL$<3>\\EQ                                                                                \\EP$<3> \\EO\\ER\\EA$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[24s' => '
#
# Stub version of: \\E[24s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E&bn%?%gA%t\\E&dA%;%?%gB%t\\E&dB%;%?%gH%t\\E&dH%;%?%gU%t\\E&bR%;%?%gV%t\\E&bG%;%?%gW%t\\E&bB%;%?%p1%{1}%&%t\\E&bb%{1}%e%{0}%;%PZ%?%p1%{2}%&%t\\E&bg%{1}%e%{0}%;%PY%?%p1%{4}%&%t\\E&br%{1}%e%{0}%;%PX' => '
#
# Stub version of: \\E&bn%?%gA%t\\E&dA%;%?%gB%t\\E&dB%;%?%gH%t\\E&dH%;%?%gU%t\\E&bR%;%?%gV%t\\E&bG%;%?%gW%t\\E&bB%;%?%p1%{1}%&%t\\E&bb%{1}%e%{0}%;%PZ%?%p1%{2}%&%t\\E&bg%{1}%e%{0}%;%PY%?%p1%{4}%&%t\\E&br%{1}%e%{0}%;%PX
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(98); # b
  $rc .= chr(110); # n
  if (do { # %?
           push(@iparam, $staticp->[0]); # %gA
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(100); # d
    $rc .= chr(65); # A
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[1]); # %gB
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(100); # d
    $rc .= chr(66); # B
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[7]); # %gH
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(100); # d
    $rc .= chr(72); # H
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[20]); # %gU
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(98); # b
    $rc .= chr(82); # R
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[21]); # %gV
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(98); # b
    $rc .= chr(71); # G
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[22]); # %gW
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(98); # b
    $rc .= chr(66); # B
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(98); # b
    $rc .= chr(98); # b
    push(@iparam, 1); # %{1}
  }
  else { # %e
    push(@iparam, 0); # %{0}
  } # %;
  $staticp->[25] = pop(@iparam); # %PZ
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 2); # %{2}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(98); # b
    $rc .= chr(103); # g
    push(@iparam, 1); # %{1}
  }
  else { # %e
    push(@iparam, 0); # %{0}
  } # %;
  $staticp->[24] = pop(@iparam); # %PY
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 4); # %{4}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(98); # b
    $rc .= chr(114); # r
    push(@iparam, 1); # %{1}
  }
  else { # %e
    push(@iparam, 0); # %{0}
  } # %;
  $staticp->[23] = pop(@iparam); # %PX

  return $rc;
}
',
          '\\E[100m' => '
#
# Stub version of: \\E[100m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '``aaffggjjkkllmmnnooqqssttuuvvwwxx~~' => '
#
# Stub version of: ``aaffggjjkkllmmnnooqqssttuuvvwwxx~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^\\008\\r' => '
#
# Stub version of: ^\\008\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(128); # \\0
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E+B' => '
#
# Stub version of: \\E+B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(66); # B

  return $rc;
}
',
          '%?%p1%{0}%=%t%{49}%e%p1%{1}%=%t%{50}%e%p1%{2}%=%t%{51}%e%p1%{3}%=%t%{52}%e%p1%{4}%=%t%{53}%e%p1%{5}%=%t%{54}%e%p1%{6}%=%t%{55}%e%p1%{7}%=%t%{102}%e%p1%{8}%=%t%{97}%e%p1%{9}%=%t%{98}%e%p1%{10}%=%t%{99}%e%p1%{11}%=%t%{101}%e%p1%{12}%=%t%{106}%e%p1%{13}%=%t%{110}%e%p1%{14}%=%t%{111}%e%p1%{15}%=%t%{56}%;\\Em0%c$<100>' => '
#
# Stub version of: %?%p1%{0}%=%t%{49}%e%p1%{1}%=%t%{50}%e%p1%{2}%=%t%{51}%e%p1%{3}%=%t%{52}%e%p1%{4}%=%t%{53}%e%p1%{5}%=%t%{54}%e%p1%{6}%=%t%{55}%e%p1%{7}%=%t%{102}%e%p1%{8}%=%t%{97}%e%p1%{9}%=%t%{98}%e%p1%{10}%=%t%{99}%e%p1%{11}%=%t%{101}%e%p1%{12}%=%t%{106}%e%p1%{13}%=%t%{110}%e%p1%{14}%=%t%{111}%e%p1%{15}%=%t%{56}%;\\Em0%c$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    push(@iparam, 49); # %{49}
  } # %;
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 1); # %{1}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 50); # %{50}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 2); # %{2}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 51); # %{51}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 52); # %{52}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 53); # %{53}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 5); # %{5}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 54); # %{54}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 55); # %{55}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 7); # %{7}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 102); # %{102}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 8); # %{8}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 97); # %{97}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 9); # %{9}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 98); # %{98}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 10); # %{10}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 99); # %{99}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 11); # %{11}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 101); # %{101}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 12); # %{12}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 106); # %{106}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 13); # %{13}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 110); # %{110}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 14); # %{14}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 111); # %{111}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 15); # %{15}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 56); # %{56}
  }
  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(48); # 0
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^J' => '
#
# Stub version of: ^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^J

  return $rc;
}
',
          '\\036%?%p1%p3%|%p6%|%tD%eE%;%?%p2%p6%|%t\\024%e\\025%;\\036P%?%p4%tI%eJ%;%?%p1%p5%|%t\\034%e\\035%;\\036FS%?%p9%t11%e00%;' => '
#
# Stub version of: \\036%?%p1%p3%|%p6%|%tD%eE%;%?%p2%p6%|%t\\024%e\\025%;\\036P%?%p4%tI%eJ%;%?%p1%p5%|%t\\034%e\\035%;\\036FS%?%p9%t11%e00%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(68); # D
  }
  else { # %e
    $rc .= chr(69); # E
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(20); # \\024
  }
  else { # %e
    $rc .= chr(21); # \\025
  } # %;
  $rc .= chr(30); # \\036
  $rc .= chr(80); # P
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(73); # I
  }
  else { # %e
    $rc .= chr(74); # J
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(28); # \\034
  }
  else { # %e
    $rc .= chr(29); # \\035
  } # %;
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
    $rc .= chr(49); # 1
  }
  else { # %e
    $rc .= chr(48); # 0
    $rc .= chr(48); # 0
  } # %;

  return $rc;
}
',
          '\\E[>1;6A' => '
#
# Stub version of: \\E[>1;6A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[21;1|\\212' => '
#
# Stub version of: \\E[21;1|\\212
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |
  $rc .= chr(138); # \\212

  return $rc;
}
',
          '\\Eq%p1%d;' => '
#
# Stub version of: \\Eq%p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\233100z' => '
#
# Stub version of: \\233100z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\233014z' => '
#
# Stub version of: \\233014z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EO7B' => '
#
# Stub version of: \\EO7B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(55); # 7
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[=2;%i%p1%dm' => '
#
# Stub version of: \\E[=2;%i%p1%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '^\\050\\r' => '
#
# Stub version of: ^\\050\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(40); # \\050
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E%p1%dE$<5>' => '
#
# Stub version of: \\E%p1%dE$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[25\\^' => '
#
# Stub version of: \\E[25\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\E[233z' => '
#
# Stub version of: \\E[233z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EW\\EF \\011' => '
#
# Stub version of: \\EW\\EF \\011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(32); #  
  $rc .= chr(9); # \\011

  return $rc;
}
',
          '+\\335\\,\\334-\\366.\\3770#`\\327a\\:f\\241g\\261h#i\\360jjkkllmmnno\\370p\\370q\\321rrssttuuvvwwxxy\\262z\\263{\\271|\\255}\\243~\\245' => '
#
# Stub version of: +\\335\\,\\334-\\366.\\3770#`\\327a\\:f\\241g\\261h#i\\360jjkkllmmnno\\370p\\370q\\321rrssttuuvvwwxxy\\262z\\263{\\271|\\255}\\243~\\245
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(221); # \\335
  $rc .= chr(128); # \\,
  $rc .= chr(220); # \\334
  $rc .= chr(45); # -
  $rc .= chr(246); # \\366
  $rc .= chr(46); # .
  $rc .= chr(255); # \\377
  $rc .= chr(48); # 0
  $rc .= chr(35); # #
  $rc .= chr(96); # `
  $rc .= chr(215); # \\327
  $rc .= chr(97); # a
  $rc .= chr(128); # \\:
  $rc .= chr(102); # f
  $rc .= chr(161); # \\241
  $rc .= chr(103); # g
  $rc .= chr(177); # \\261
  $rc .= chr(104); # h
  $rc .= chr(35); # #
  $rc .= chr(105); # i
  $rc .= chr(240); # \\360
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(248); # \\370
  $rc .= chr(112); # p
  $rc .= chr(248); # \\370
  $rc .= chr(113); # q
  $rc .= chr(209); # \\321
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(178); # \\262
  $rc .= chr(122); # z
  $rc .= chr(179); # \\263
  $rc .= chr(123); # {
  $rc .= chr(185); # \\271
  $rc .= chr(124); # |
  $rc .= chr(173); # \\255
  $rc .= chr(125); # }
  $rc .= chr(163); # \\243
  $rc .= chr(126); # ~
  $rc .= chr(165); # \\245

  return $rc;
}
',
          '\\E\\001\\E4' => '
#
# Stub version of: \\E\\001\\E4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4

  return $rc;
}
',
          '^^x' => '
#
# Stub version of: ^^x
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\E[4l\\E[34l\\E[?1l\\E[?3l\\E[?5l\\E[?7h' => '
#
# Stub version of: \\E[4l\\E[34l\\E[?1l\\E[?3l\\E[?5l\\E[?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '^^PA' => '
#
# Stub version of: ^^PA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P
  $rc .= chr(65); # A

  return $rc;
}
',
          'PgDn' => '
#
# Stub version of: PgDn
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(80); # P
  $rc .= chr(103); # g
  $rc .= chr(68); # D
  $rc .= chr(110); # n

  return $rc;
}
',
          '^A>2' => '
#
# Stub version of: ^A>2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(62); # >
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E[H' => '
#
# Stub version of: \\E[H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\017\\025\\035\\036E' => '
#
# Stub version of: \\017\\025\\035\\036E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(21); # \\025
  $rc .= chr(29); # \\035
  $rc .= chr(30); # \\036
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\233110z' => '
#
# Stub version of: \\233110z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[K$<6>' => '
#
# Stub version of: \\E[K$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[K\\E[t' => '
#
# Stub version of: \\E[K\\E[t
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\E%%!1\\E[?6l\\E[2J' => '
#
# Stub version of: \\E%%!1\\E[?6l\\E[2J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= \'%\';
  $rc .= chr(33); # !
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J

  return $rc;
}
',
          '^A9\\r' => '
#
# Stub version of: ^A9\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(57); # 9
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EJ$<50/>' => '
#
# Stub version of: \\EJ$<50/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ei4' => '
#
# Stub version of: \\Ei4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(105); # i
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\E[2;1v' => '
#
# Stub version of: \\E[2;1v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\E[32m\\E[40m' => '
#
# Stub version of: \\E[32m\\E[40m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[I' => '
#
# Stub version of: \\E[I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\E0        \\E1        \\E1        \\E1        \\E1        \\E1        \\E1        \\E1        \\E1' => '
#
# Stub version of: \\E0        \\E1        \\E1        \\E1        \\E1        \\E1        \\E1        \\E1        \\E1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1

  return $rc;
}
',
          '/usr/share/tabset/std' => '
#
# Stub version of: /usr/share/tabset/std
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(47); # /
  $rc .= chr(117); # u
  $rc .= chr(115); # s
  $rc .= chr(114); # r
  $rc .= chr(47); # /
  $rc .= chr(115); # s
  $rc .= chr(104); # h
  $rc .= chr(97); # a
  $rc .= chr(114); # r
  $rc .= chr(101); # e
  $rc .= chr(47); # /
  $rc .= chr(116); # t
  $rc .= chr(97); # a
  $rc .= chr(98); # b
  $rc .= chr(115); # s
  $rc .= chr(101); # e
  $rc .= chr(116); # t
  $rc .= chr(47); # /
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\EJ$<75>' => '
#
# Stub version of: \\EJ$<75>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1;3C' => '
#
# Stub version of: \\E[1;3C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(67); # C

  return $rc;
}
',
          '^\\^H' => '
#
# Stub version of: ^\\^H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(128); # \\^
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[L$<4>' => '
#
# Stub version of: \\E[L$<4>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EI$<20>' => '
#
# Stub version of: \\EI$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\233?1049h' => '
#
# Stub version of: \\233?1049h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[%p1%dL$<5*>' => '
#
# Stub version of: \\E[%p1%dL$<5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[22m' => '
#
# Stub version of: \\E[22m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E>\\E(B\\E)0\\017' => '
#
# Stub version of: \\E>\\E(B\\E)0\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '^PB' => '
#
# Stub version of: ^PB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[100z' => '
#
# Stub version of: \\E[100z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EL$<2*/>' => '
#
# Stub version of: \\EL$<2*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '^P^U' => '
#
# Stub version of: ^P^U
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(0); # ^U

  return $rc;
}
',
          '\\E[0K' => '
#
# Stub version of: \\E[0K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E?i' => '
#
# Stub version of: \\E?i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E[?;2i' => '
#
# Stub version of: \\E[?;2i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E]2;' => '
#
# Stub version of: \\E]2;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\EO1;2B' => '
#
# Stub version of: \\EO1;2B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\2332~' => '
#
# Stub version of: \\2332~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EV%p1%c' => '
#
# Stub version of: \\EV%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[13r' => '
#
# Stub version of: \\E[13r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E!^C' => '
#
# Stub version of: \\E!^C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(0); # ^C

  return $rc;
}
',
          '\\E4"a' => '
#
# Stub version of: \\E4"a
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(34); # "
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\E[19s' => '
#
# Stub version of: \\E[19s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\Ek\\010\\Em\\010\\Eq\\032' => '
#
# Stub version of: \\Ek\\010\\Em\\010\\Eq\\032
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(26); # \\032

  return $rc;
}
',
          '\\EF\\EQ\\EM \\ER 7' => '
#
# Stub version of: \\EF\\EQ\\EM \\ER 7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(32); #  
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\END' => '
#
# Stub version of: \\END
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\EO4P' => '
#
# Stub version of: \\EO4P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(52); # 4
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\0o' => '
#
# Stub version of: \\0o
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\E[1$~' => '
#
# Stub version of: \\E[1$~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^B#\\r' => '
#
# Stub version of: ^B#\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(35); # #
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\002%p2%{32}%+%c%p1%{32}%+%c' => '
#
# Stub version of: \\002%p2%{32}%+%c%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(2); # \\002
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[W' => '
#
# Stub version of: \\E[W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\E#;' => '
#
# Stub version of: \\E#;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E%%!0\\ETF4%?%p1%{0}%=%t0%e%p1%{1}%=%t4%e%p1%{2}%=%t3%e%p1%{3}%=%t5%e%p1%{4}%=%t2%e%p1%{5}%=%t6%e%p1%{6}%=%t7%e1%;%?%p2%{125}%<%t0%e%p2%{250}%<%tA2%e%p2%{375}%<%tA?%e%p2%{500}%<%tC8%e%p2%{625}%<%tD4%e%p2%{750}%<%tE1%e%p2%{875}%<%tE\\:%eF4%;%?%p3%{125}%<%t0%e%p3%{250}%<%tA2%e%p3%{375}%<%tA?%e%p3%{500}%<%tC8%e%p3%{625}%<%tD4%e%p3%{750}%<%tE1%e%p3%{875}%<%tE\\:%eF4%;%?%p4%{125}%<%t0%e%p4%{250}%<%tA2%e%p4%{375}%<%tA?%e%p4%{500}%<%tC8%e%p4%{625}%<%tD4%e%p4%{750}%<%tE1%e%p4%{875}%<%tE\\:%eF4%;\\E%%!1' => '
#
# Stub version of: \\E%%!0\\ETF4%?%p1%{0}%=%t0%e%p1%{1}%=%t4%e%p1%{2}%=%t3%e%p1%{3}%=%t5%e%p1%{4}%=%t2%e%p1%{5}%=%t6%e%p1%{6}%=%t7%e1%;%?%p2%{125}%<%t0%e%p2%{250}%<%tA2%e%p2%{375}%<%tA?%e%p2%{500}%<%tC8%e%p2%{625}%<%tD4%e%p2%{750}%<%tE1%e%p2%{875}%<%tE\\:%eF4%;%?%p3%{125}%<%t0%e%p3%{250}%<%tA2%e%p3%{375}%<%tA?%e%p3%{500}%<%tC8%e%p3%{625}%<%tD4%e%p3%{750}%<%tE1%e%p3%{875}%<%tE\\:%eF4%;%?%p4%{125}%<%t0%e%p4%{250}%<%tA2%e%p4%{375}%<%tA?%e%p4%{500}%<%tC8%e%p4%{625}%<%tD4%e%p4%{750}%<%tE1%e%p4%{875}%<%tE\\:%eF4%;\\E%%!1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= \'%\';
  $rc .= chr(33); # !
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 1); # %{1}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 2); # %{2}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 5); # %{5}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
  }
  else { # %e
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, 125); # %{125}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
  }
  elsif (do { # %e
              push(@iparam, $param[1]); # %p2
              push(@iparam, 250); # %{250}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(65); # A
    $rc .= chr(50); # 2
  }
  elsif (do { # %e
              push(@iparam, $param[1]); # %p2
              push(@iparam, 375); # %{375}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(65); # A
    $rc .= chr(63); # ?
  }
  elsif (do { # %e
              push(@iparam, $param[1]); # %p2
              push(@iparam, 500); # %{500}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(67); # C
    $rc .= chr(56); # 8
  }
  elsif (do { # %e
              push(@iparam, $param[1]); # %p2
              push(@iparam, 625); # %{625}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(68); # D
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $param[1]); # %p2
              push(@iparam, 750); # %{750}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(69); # E
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $param[1]); # %p2
              push(@iparam, 875); # %{875}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(69); # E
    $rc .= chr(128); # \\:
  }
  else { # %e
    $rc .= chr(70); # F
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, 125); # %{125}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
  }
  elsif (do { # %e
              push(@iparam, $param[2]); # %p3
              push(@iparam, 250); # %{250}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(65); # A
    $rc .= chr(50); # 2
  }
  elsif (do { # %e
              push(@iparam, $param[2]); # %p3
              push(@iparam, 375); # %{375}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(65); # A
    $rc .= chr(63); # ?
  }
  elsif (do { # %e
              push(@iparam, $param[2]); # %p3
              push(@iparam, 500); # %{500}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(67); # C
    $rc .= chr(56); # 8
  }
  elsif (do { # %e
              push(@iparam, $param[2]); # %p3
              push(@iparam, 625); # %{625}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(68); # D
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $param[2]); # %p3
              push(@iparam, 750); # %{750}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(69); # E
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $param[2]); # %p3
              push(@iparam, 875); # %{875}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(69); # E
    $rc .= chr(128); # \\:
  }
  else { # %e
    $rc .= chr(70); # F
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           push(@iparam, 125); # %{125}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
  }
  elsif (do { # %e
              push(@iparam, $param[3]); # %p4
              push(@iparam, 250); # %{250}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(65); # A
    $rc .= chr(50); # 2
  }
  elsif (do { # %e
              push(@iparam, $param[3]); # %p4
              push(@iparam, 375); # %{375}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(65); # A
    $rc .= chr(63); # ?
  }
  elsif (do { # %e
              push(@iparam, $param[3]); # %p4
              push(@iparam, 500); # %{500}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(67); # C
    $rc .= chr(56); # 8
  }
  elsif (do { # %e
              push(@iparam, $param[3]); # %p4
              push(@iparam, 625); # %{625}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(68); # D
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $param[3]); # %p4
              push(@iparam, 750); # %{750}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(69); # E
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $param[3]); # %p4
              push(@iparam, 875); # %{875}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(69); # E
    $rc .= chr(128); # \\:
  }
  else { # %e
    $rc .= chr(70); # F
    $rc .= chr(52); # 4
  } # %;
  $rc .= chr(27); # \\E
  $rc .= \'%\';
  $rc .= chr(33); # !
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[0%?%p6%t;35%;%?%p2%t;4%;%?%p1%p3%|%t;7%;m' => '
#
# Stub version of: \\E[0%?%p6%t;35%;%?%p2%t;4%;%?%p1%p3%|%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(51); # 3
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '^V\'^B' => '
#
# Stub version of: ^V\'^B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(39); # \'
  $rc .= chr(0); # ^B

  return $rc;
}
',
          '%?%p8%t\\E)%e\\E(%;%?%p9%t\\EH\\002%e\\EH\\003%;\\EG%{48}%?%p2%t%{8}%|%;%?%p1%p3%|%t%{4}%|%;%?%p4%t%{2}%|%;%?%p1%p5%|%t%{64}%|%;%?%p7%t%{1}%|%;%c' => '
#
# Stub version of: %?%p8%t\\E)%e\\E(%;%?%p9%t\\EH\\002%e\\EH\\003%;\\EG%{48}%?%p2%t%{8}%|%;%?%p1%p3%|%t%{4}%|%;%?%p4%t%{2}%|%;%?%p1%p5%|%t%{64}%|%;%?%p7%t%{1}%|%;%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[7]); # %p8
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(41); # )
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(72); # H
    $rc .= chr(2); # \\002
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(72); # H
    $rc .= chr(3); # \\003
  } # %;
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  push(@iparam, 48); # %{48}
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    push(@iparam, 8); # %{8}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 64); # %{64}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\036RG2%p1%{16}%/%{48}%+%c%p1%{16}%m%{48}%+%c' => '
#
# Stub version of: \\036RG2%p1%{16}%/%{48}%+%c%p1%{16}%m%{48}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(71); # G
  $rc .= chr(50); # 2
  push(@iparam, $param[0]); # %p1
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\ENh' => '
#
# Stub version of: \\ENh
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\377\\352' => '
#
# Stub version of: \\377\\352
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(234); # \\352

  return $rc;
}
',
          '\\E[27m' => '
#
# Stub version of: \\E[27m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[314z' => '
#
# Stub version of: \\E[314z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[=103h\\E[=205h' => '
#
# Stub version of: \\E[=103h\\E[=205h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E\\:' => '
#
# Stub version of: \\E\\:
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\:

  return $rc;
}
',
          '\\036FG\\027' => '
#
# Stub version of: \\036FG\\027
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(71); # G
  $rc .= chr(23); # \\027

  return $rc;
}
',
          '\\EE$<3>\\EX\\EZ\\EO\\Eb\\Eg\\ER' => '
#
# Stub version of: \\EE$<3>\\EX\\EZ\\EO\\Eb\\Eg\\ER
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(90); # Z
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\EcB1\\EH\\002' => '
#
# Stub version of: \\EcB1\\EH\\002
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(66); # B
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(2); # \\002

  return $rc;
}
',
          '\\E[24E' => '
#
# Stub version of: \\E[24E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\E)4\\017' => '
#
# Stub version of: \\E)4\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(52); # 4
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\ENK' => '
#
# Stub version of: \\ENK
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E[225z' => '
#
# Stub version of: \\E[225z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[!p\\E[?7;19;67h\\E[?1;3;4l\\E[1;0%w\\E(B\\E)0\\017\\E[2J\\E[1;1H\\E>$<200>' => '
#
# Stub version of: \\E[!p\\E[?7;19;67h\\E[?1;3;4l\\E[1;0%w\\E(B\\E)0\\017\\E[2J\\E[1;1H\\E>$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(37); # %
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EFt' => '
#
# Stub version of: \\EFt
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\E[26s' => '
#
# Stub version of: \\E[26s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\EG0\\E[=5l' => '
#
# Stub version of: \\EG0\\E[=5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\Ee\\E z\\s' => '
#
# Stub version of: \\Ee\\E z\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(122); # z
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E7\\E[r\\E8\\E[m\\E[?7h\\E[?1;3;4;6l\\E[4l\\E>\\E[?1000l' => '
#
# Stub version of: \\E7\\E[r\\E8\\E[m\\E[?7h\\E[?1;3;4;6l\\E[4l\\E>\\E[?1000l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[J\\E[r' => '
#
# Stub version of: \\E[J\\E[r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r

  return $rc;
}
',
          '^TC2' => '
#
# Stub version of: ^TC2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^T
  $rc .= chr(67); # C
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\EM0' => '
#
# Stub version of: \\EM0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\377\\304' => '
#
# Stub version of: \\377\\304
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(196); # \\304

  return $rc;
}
',
          '\\E7\\E[60;0;0;20p\\E8' => '
#
# Stub version of: \\E7\\E[60;0;0;20p\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E%?%p1%p5%|%t)%e(%;' => '
#
# Stub version of: \\E%?%p1%p5%|%t)%e(%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(41); # )
  }
  else { # %e
    $rc .= chr(40); # (
  } # %;

  return $rc;
}
',
          '\\Ey1' => '
#
# Stub version of: \\Ey1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(49); # 1

  return $rc;
}
',
          'F6' => '
#
# Stub version of: F6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E[B\\E[L$<80>' => '
#
# Stub version of: \\E[B\\E[L$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\23328~' => '
#
# Stub version of: \\23328~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E!T' => '
#
# Stub version of: \\E!T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\E[222z' => '
#
# Stub version of: \\E[222z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[11;1|' => '
#
# Stub version of: \\E[11;1|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\233?' => '
#
# Stub version of: \\233?
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?

  return $rc;
}
',
          '\\0\\^' => '
#
# Stub version of: \\0\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\EG0\\E)' => '
#
# Stub version of: \\EG0\\E)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )

  return $rc;
}
',
          '\\EQ$<30>' => '
#
# Stub version of: \\EQ$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[208z' => '
#
# Stub version of: \\E[208z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E)B' => '
#
# Stub version of: \\E)B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E<\\E[20l\\E[?3;6;9l\\E[r\\Eq\\E(B\\017\\E)0\\E>' => '
#
# Stub version of: \\E<\\E[20l\\E[?3;6;9l\\E[r\\Eq\\E(B\\017\\E)0\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          'P$<\\233>' => '
#
# Stub version of: P$<\\233>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(155); # \\233
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E!j\\r' => '
#
# Stub version of: \\E!j\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(106); # j
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^]8`g @\\037' => '
#
# Stub version of: ^]8`g @\\037
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^]
  $rc .= chr(56); # 8
  $rc .= chr(96); # `
  $rc .= chr(103); # g
  $rc .= chr(32); #  
  $rc .= chr(64); # @
  $rc .= chr(31); # \\037

  return $rc;
}
',
          '\\E[=2;<3m' => '
#
# Stub version of: \\E[=2;<3m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E&a-%p1%dC' => '
#
# Stub version of: \\E&a-%p1%dC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  $rc .= chr(45); # -
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C

  return $rc;
}
',
          '^B7\\r' => '
#
# Stub version of: ^B7\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(55); # 7
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[18;2~' => '
#
# Stub version of: \\E[18;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[M$<5>' => '
#
# Stub version of: \\E[M$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E7\\E[r\\E[m\\E[?7h\\E[?1;3;4;6l\\E[4l\\E8\\E>' => '
#
# Stub version of: \\E7\\E[r\\E[m\\E[?7h\\E[?1;3;4;6l\\E[4l\\E8\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          'F10' => '
#
# Stub version of: F10
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[0J$<15>' => '
#
# Stub version of: \\E[0J$<15>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&a%p2%dc%p1%dR' => '
#
# Stub version of: \\E&a%p2%dc%p1%dR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(99); # c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\233K' => '
#
# Stub version of: \\233K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\EF%p1%{32}%+%c' => '
#
# Stub version of: \\EF%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E#R' => '
#
# Stub version of: \\E#R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E^L' => '
#
# Stub version of: \\E^L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^L

  return $rc;
}
',
          '\\E/>7h' => '
#
# Stub version of: \\E/>7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\036%?%p1%p3%|%p6%|%tD%eE%;%?%p2%p6%|%t\\024%e\\025%;%?%p4%t\\016%e\\017%;%?%p1%p5%|%t\\034%e\\035%;' => '
#
# Stub version of: \\036%?%p1%p3%|%p6%|%tD%eE%;%?%p2%p6%|%t\\024%e\\025%;%?%p4%t\\016%e\\017%;%?%p1%p5%|%t\\034%e\\035%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(68); # D
  }
  else { # %e
    $rc .= chr(69); # E
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(20); # \\024
  }
  else { # %e
    $rc .= chr(21); # \\025
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(28); # \\034
  }
  else { # %e
    $rc .= chr(29); # \\035
  } # %;

  return $rc;
}
',
          '\\EK$<70>' => '
#
# Stub version of: \\EK$<70>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E$' => '
#
# Stub version of: \\E$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\E[35h\\E[?3h$<70>' => '
#
# Stub version of: \\E[35h\\E[?3h$<70>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '2[3@4>5I9(\\:\'JSKWLQMAO#P$Q;R!S"T1U2V4W3X\\:Y+Z*dHjGkTlRmFn/q\\,t5u6v8w7x.' => '
#
# Stub version of: 2[3@4>5I9(\\:\'JSKWLQMAO#P$Q;R!S"T1U2V4W3X\\:Y+Z*dHjGkTlRmFn/q\\,t5u6v8w7x.
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(50); # 2
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(64); # @
  $rc .= chr(52); # 4
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(73); # I
  $rc .= chr(57); # 9
  $rc .= chr(40); # (
  $rc .= chr(128); # \\:
  $rc .= chr(39); # \'
  $rc .= chr(74); # J
  $rc .= chr(83); # S
  $rc .= chr(75); # K
  $rc .= chr(87); # W
  $rc .= chr(76); # L
  $rc .= chr(81); # Q
  $rc .= chr(77); # M
  $rc .= chr(65); # A
  $rc .= chr(79); # O
  $rc .= chr(35); # #
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(81); # Q
  $rc .= chr(59); # ;
  $rc .= chr(82); # R
  $rc .= chr(33); # !
  $rc .= chr(83); # S
  $rc .= chr(34); # "
  $rc .= chr(84); # T
  $rc .= chr(49); # 1
  $rc .= chr(85); # U
  $rc .= chr(50); # 2
  $rc .= chr(86); # V
  $rc .= chr(52); # 4
  $rc .= chr(87); # W
  $rc .= chr(51); # 3
  $rc .= chr(88); # X
  $rc .= chr(128); # \\:
  $rc .= chr(89); # Y
  $rc .= chr(43); # +
  $rc .= chr(90); # Z
  $rc .= chr(42); # *
  $rc .= chr(100); # d
  $rc .= chr(72); # H
  $rc .= chr(106); # j
  $rc .= chr(71); # G
  $rc .= chr(107); # k
  $rc .= chr(84); # T
  $rc .= chr(108); # l
  $rc .= chr(82); # R
  $rc .= chr(109); # m
  $rc .= chr(70); # F
  $rc .= chr(110); # n
  $rc .= chr(47); # /
  $rc .= chr(113); # q
  $rc .= chr(128); # \\,
  $rc .= chr(116); # t
  $rc .= chr(53); # 5
  $rc .= chr(117); # u
  $rc .= chr(54); # 6
  $rc .= chr(118); # v
  $rc .= chr(56); # 8
  $rc .= chr(119); # w
  $rc .= chr(55); # 7
  $rc .= chr(120); # x
  $rc .= chr(46); # .

  return $rc;
}
',
          '\\E1%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\E1%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E\\\\2\\E-07\\s' => '
#
# Stub version of: \\E\\\\2\\E-07\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(45); # -
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E."' => '
#
# Stub version of: \\E."
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(34); # "

  return $rc;
}
',
          '\\EB\\r' => '
#
# Stub version of: \\EB\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(66); # B
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^X' => '
#
# Stub version of: ^X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^X

  return $rc;
}
',
          '\\E^B\\r' => '
#
# Stub version of: \\E^B\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^B
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[7;8m' => '
#
# Stub version of: \\E[7;8m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E\\003\\E2' => '
#
# Stub version of: \\E\\003\\E2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E[J$<10>' => '
#
# Stub version of: \\E[J$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%?%p1%t7;%;%?%p2%t4;%;%?%p3%t7;%;%?%p4%t5;%;%?%p6%t1;%;m' => '
#
# Stub version of: \\E[%?%p1%t7;%;%?%p2%t4;%;%?%p3%t7;%;%?%p4%t5;%;%?%p6%t1;%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
    $rc .= chr(59); # ;
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EK$<100>\\EK' => '
#
# Stub version of: \\EK$<100>\\EK
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\233306z' => '
#
# Stub version of: \\233306z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(122); # z

  return $rc;
}
',
          'K2 UCB IBMPC Kermit 1.2  8-30-84\\n' => '
#
# Stub version of: K2 UCB IBMPC Kermit 1.2  8-30-84\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(75); # K
  $rc .= chr(50); # 2
  $rc .= chr(32); #  
  $rc .= chr(85); # U
  $rc .= chr(67); # C
  $rc .= chr(66); # B
  $rc .= chr(32); #  
  $rc .= chr(73); # I
  $rc .= chr(66); # B
  $rc .= chr(77); # M
  $rc .= chr(80); # P
  $rc .= chr(67); # C
  $rc .= chr(32); #  
  $rc .= chr(75); # K
  $rc .= chr(101); # e
  $rc .= chr(114); # r
  $rc .= chr(109); # m
  $rc .= chr(105); # i
  $rc .= chr(116); # t
  $rc .= chr(32); #  
  $rc .= chr(49); # 1
  $rc .= chr(46); # .
  $rc .= chr(50); # 2
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(56); # 8
  $rc .= chr(45); # -
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(45); # -
  $rc .= chr(56); # 8
  $rc .= chr(52); # 4
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\E"U' => '
#
# Stub version of: \\E"U
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(85); # U

  return $rc;
}
',
          '\\E[?5W' => '
#
# Stub version of: \\E[?5W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\E[=1;0m' => '
#
# Stub version of: \\E[=1;0m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '^CD' => '
#
# Stub version of: ^CD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^C
  $rc .= chr(68); # D

  return $rc;
}
',
          '/usr/share/tabset/stdcrt' => '
#
# Stub version of: /usr/share/tabset/stdcrt
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(47); # /
  $rc .= chr(117); # u
  $rc .= chr(115); # s
  $rc .= chr(114); # r
  $rc .= chr(47); # /
  $rc .= chr(115); # s
  $rc .= chr(104); # h
  $rc .= chr(97); # a
  $rc .= chr(114); # r
  $rc .= chr(101); # e
  $rc .= chr(47); # /
  $rc .= chr(116); # t
  $rc .= chr(97); # a
  $rc .= chr(98); # b
  $rc .= chr(115); # s
  $rc .= chr(101); # e
  $rc .= chr(116); # t
  $rc .= chr(47); # /
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(100); # d
  $rc .= chr(99); # c
  $rc .= chr(114); # r
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\EH' => '
#
# Stub version of: \\EH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[m\\017\\E["q' => '
#
# Stub version of: \\E[m\\017\\E["q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(34); # "
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E(B\\E)1\\E[2l' => '
#
# Stub version of: \\E(B\\E)1\\E[2l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\036FQ0' => '
#
# Stub version of: \\036FQ0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(81); # Q
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[33\\^' => '
#
# Stub version of: \\E[33\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\E=%p1%{32}%+%c%p2%{32}%+%c$<1/>' => '
#
# Stub version of: \\E=%p1%{32}%+%c%p2%{32}%+%c$<1/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[ R' => '
#
# Stub version of: \\E[ R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(32); #  
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\377\\334' => '
#
# Stub version of: \\377\\334
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(220); # \\334

  return $rc;
}
',
          '\\E(B$<5>' => '
#
# Stub version of: \\E(B$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[>59h' => '
#
# Stub version of: \\E[>59h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(57); # 9
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EO1;4Q' => '
#
# Stub version of: \\EO1;4Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E[>12l' => '
#
# Stub version of: \\E[>12l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(108); # l

  return $rc;
}
',
          '^\\^P^P' => '
#
# Stub version of: ^\\^P^P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(128); # \\^
  $rc .= chr(80); # P
  $rc .= chr(0); # ^P

  return $rc;
}
',
          '\\Ea^D' => '
#
# Stub version of: \\Ea^D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(97); # a
  $rc .= chr(0); # ^D

  return $rc;
}
',
          '\\E(0$<5>' => '
#
# Stub version of: \\E(0$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1P$<80>' => '
#
# Stub version of: \\E[1P$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EOF' => '
#
# Stub version of: \\EOF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E[%i%p1%2d;%p2%2dH\\E[B' => '
#
# Stub version of: \\E[%i%p1%2d;%p2%2dH\\E[B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E\\^9;0s\\E\\^7;1s\\E[3g\\E\\^11;9s\\E\\^11;17s\\E\\^11;25s\\E\\^11;33s\\E\\^11;41s\\E\\^11;49s\\E\\^11;57s\\E\\^11;65s\\E\\^11;73s\\E\\^11;81s\\E\\^11;89s' => '
#
# Stub version of: \\E\\^9;0s\\E\\^7;1s\\E[3g\\E\\^11;9s\\E\\^11;17s\\E\\^11;25s\\E\\^11;33s\\E\\^11;41s\\E\\^11;49s\\E\\^11;57s\\E\\^11;65s\\E\\^11;73s\\E\\^11;81s\\E\\^11;89s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(55); # 7
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(49); # 1
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(57); # 9
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\036FG\\036PH' => '
#
# Stub version of: \\036FG\\036PH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(71); # G
  $rc .= chr(30); # \\036
  $rc .= chr(80); # P
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\Eq$<10/>' => '
#
# Stub version of: \\Eq$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\n$<10>' => '
#
# Stub version of: \\n$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^B*\\r' => '
#
# Stub version of: ^B*\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(42); # *
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^^FH' => '
#
# Stub version of: ^^FH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(70); # F
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\377\\360' => '
#
# Stub version of: \\377\\360
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(240); # \\360

  return $rc;
}
',
          '\\E[?21h' => '
#
# Stub version of: \\E[?21h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\233112z' => '
#
# Stub version of: \\233112z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EI$<2/>' => '
#
# Stub version of: \\EI$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[@$<9/>' => '
#
# Stub version of: \\E[@$<9/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(64); # @
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(57); # 9
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EG1B@\\EH' => '
#
# Stub version of: \\EG1B@\\EH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(49); # 1
  $rc .= chr(66); # B
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\233?7h' => '
#
# Stub version of: \\233?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[021z' => '
#
# Stub version of: \\E[021z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E 1' => '
#
# Stub version of: \\E 1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\0S' => '
#
# Stub version of: \\0S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E[60;0;0;30p\\E[60;1H\\E[K' => '
#
# Stub version of: \\E[60;0;0;30p\\E[60;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\EOa' => '
#
# Stub version of: \\EOa
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\EU\\Ev  8\\001D\\Ep\\r' => '
#
# Stub version of: \\EU\\Ev  8\\001D\\Ep\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(56); # 8
  $rc .= chr(1); # \\001
  $rc .= chr(68); # D
  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%i%i%p1%d;%p2%dr' => '
#
# Stub version of: \\E[%i%i%p1%d;%p2%dr
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[=103l\\E[=205l' => '
#
# Stub version of: \\E[=103l\\E[=205l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '^\\009\\r' => '
#
# Stub version of: ^\\009\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(128); # \\0
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EO1;3A' => '
#
# Stub version of: \\EO1;3A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[0%?%p5%p6%|%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%p6%|%t;7%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p5%p6%|%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%p6%|%t;7%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[0]); # %p1
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\017\\035\\E(B\\E)0\\E[?7h\\E[?3h\\E[>8g' => '
#
# Stub version of: \\017\\035\\E(B\\E)0\\E[?7h\\E[?3h\\E[>8g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(29); # \\035
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(56); # 8
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\034E$<15>' => '
#
# Stub version of: \\034E$<15>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(28); # \\034
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          'f1' => '
#
# Stub version of: f1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(102); # f
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[31;2~' => '
#
# Stub version of: \\E[31;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[4m' => '
#
# Stub version of: \\E[4m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Ef6' => '
#
# Stub version of: \\Ef6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E[19;6~' => '
#
# Stub version of: \\E[19;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\ED\\EJ$<500>\\EC' => '
#
# Stub version of: \\ED\\EJ$<500>\\EC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[31h' => '
#
# Stub version of: \\E[31h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E&v0m1b0i&j@' => '
#
# Stub version of: \\E&v0m1b0i&j@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(49); # 1
  $rc .= chr(98); # b
  $rc .= chr(48); # 0
  $rc .= chr(105); # i
  $rc .= chr(38); # &
  $rc .= chr(106); # j
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\377\\237' => '
#
# Stub version of: \\377\\237
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(159); # \\237

  return $rc;
}
',
          '\\Ec\\E[?4l\\E[12h' => '
#
# Stub version of: \\Ec\\E[?4l\\E[12h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[8@' => '
#
# Stub version of: \\E[8@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[24;80H' => '
#
# Stub version of: \\E[24;80H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\EOM' => '
#
# Stub version of: \\EOM
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\036P@1\\036FK\\036FX0083' => '
#
# Stub version of: \\036P@1\\036FK\\036FX0083
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(80); # P
  $rc .= chr(64); # @
  $rc .= chr(49); # 1
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(75); # K
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(88); # X
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\233%p1%dC' => '
#
# Stub version of: \\233%p1%dC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C

  return $rc;
}
',
          '^^P0' => '
#
# Stub version of: ^^P0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[2I' => '
#
# Stub version of: \\E[2I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\Ec20\\Ec30' => '
#
# Stub version of: \\Ec20\\Ec30
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[%p1%\'(\'%+%dm' => '
#
# Stub version of: \\E[%p1%\'(\'%+%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  push(@iparam, chr(40)); # %\'(\'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[%p1%d;0;0;0q%p2%:-16.16s' => '
#
# Stub version of: \\E[%p1%d;0;0;0q%p2%:-16.16s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(113); # q
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%-16.16s\', pop(@iparam)); # %-16.16s

  return $rc;
}
',
          '\\032$<50>' => '
#
# Stub version of: \\032$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(26); # \\032
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[030q' => '
#
# Stub version of: \\E[030q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[111z' => '
#
# Stub version of: \\E[111z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\ER\\E0@\\EV' => '
#
# Stub version of: \\ER\\E0@\\EV
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V

  return $rc;
}
',
          '9' => '
#
# Stub version of: 9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\233Z' => '
#
# Stub version of: \\233Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\E[62;%p1%dw' => '
#
# Stub version of: \\E[62;%p1%dw
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\E[%p1%dp%p2%:-16s' => '
#
# Stub version of: \\E[%p1%dp%p2%:-16s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(112); # p
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%-16s\', pop(@iparam)); # %-16s

  return $rc;
}
',
          '\\E[%p1%dG' => '
#
# Stub version of: \\E[%p1%dG
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\EE$<33*>' => '
#
# Stub version of: \\EE$<33*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[m\\E[10m' => '
#
# Stub version of: \\E[m\\E[10m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EF20' => '
#
# Stub version of: \\EF20
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\EP \\010' => '
#
# Stub version of: \\EP \\010
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(32); #  
  $rc .= chr(8); # \\010

  return $rc;
}
',
          '\\E[%p1%dX$<5>' => '
#
# Stub version of: \\E[%p1%dX$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(88); # X
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\233303z' => '
#
# Stub version of: \\233303z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\037dli %p1%d\\r\\006' => '
#
# Stub version of: \\037dli %p1%d\\r\\006
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(100); # d
  $rc .= chr(108); # l
  $rc .= chr(105); # i
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(13); # \\r
  $rc .= chr(6); # \\006

  return $rc;
}
',
          '^R' => '
#
# Stub version of: ^R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^R

  return $rc;
}
',
          '\\0h' => '
#
# Stub version of: \\0h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\Ej$<7>' => '
#
# Stub version of: \\Ej$<7>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EN' => '
#
# Stub version of: \\EN
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N

  return $rc;
}
',
          '\\E?r' => '
#
# Stub version of: \\E?r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\010$<6>' => '
#
# Stub version of: \\010$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(8); # \\010
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\032$<40>' => '
#
# Stub version of: \\E\\032$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(26); # \\032
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EwG\\Ee($<100>' => '
#
# Stub version of: \\EwG\\Ee($<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(40); # (
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EE$<8.5*>' => '
#
# Stub version of: \\EE$<8.5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[11;0|' => '
#
# Stub version of: \\E[11;0|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\23341~' => '
#
# Stub version of: \\23341~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[0;1m' => '
#
# Stub version of: \\E[0;1m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\0a' => '
#
# Stub version of: \\0a
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\E[1M' => '
#
# Stub version of: \\E[1M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(77); # M

  return $rc;
}
',
          '^Z4' => '
#
# Stub version of: ^Z4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Z
  $rc .= chr(52); # 4

  return $rc;
}
',
          '^Ao\\r' => '
#
# Stub version of: ^Ao\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(111); # o
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^AI\\r' => '
#
# Stub version of: ^AI\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(73); # I
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[5;7~' => '
#
# Stub version of: \\E[5;7~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^E' => '
#
# Stub version of: ^E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^E

  return $rc;
}
',
          '\\E[5~' => '
#
# Stub version of: \\E[5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E7\\E[?47h' => '
#
# Stub version of: \\E7\\E[?47h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\n$<150*>' => '
#
# Stub version of: \\n$<150*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E1$<5>' => '
#
# Stub version of: \\E1$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E^D' => '
#
# Stub version of: \\E^D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^D

  return $rc;
}
',
          '\\E[11;1j' => '
#
# Stub version of: \\E[11;1j
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j

  return $rc;
}
',
          '\\2330r' => '
#
# Stub version of: \\2330r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[218z' => '
#
# Stub version of: \\E[218z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\035%{3103}%{91}%p1%*%-%Py%p2%{55}%*%Px%gy%{128}%/%{31}%&%{32}%+%c%gy%{3}%&%{4}%*%gx%{3}%&%+%{96}%+%c%gy%{004}%/%{31}%&%{96}%+%c%gx%{128}%/%{31}%&%{32}%+%c%gx%{004}%/%{31}%&%{64}%+%c\\037' => '
#
# Stub version of: \\035%{3103}%{91}%p1%*%-%Py%p2%{55}%*%Px%gy%{128}%/%{31}%&%{32}%+%c%gy%{3}%&%{4}%*%gx%{3}%&%+%{96}%+%c%gy%{004}%/%{31}%&%{96}%+%c%gx%{128}%/%{31}%&%{32}%+%c%gx%{004}%/%{31}%&%{64}%+%c\\037
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  push(@iparam, 3103); # %{3103}
  push(@iparam, 91); # %{91}
  push(@iparam, $param[0]); # %p1
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  $dynamicp->[24] = pop(@iparam); # %Py
  push(@iparam, $param[1]); # %p2
  push(@iparam, 55); # %{55}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  $dynamicp->[23] = pop(@iparam); # %Px
  push(@iparam, $dynamicp->[24]); # %gy
  push(@iparam, 128); # %{128}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[24]); # %gy
  push(@iparam, 3); # %{3}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 4); # %{4}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, $dynamicp->[23]); # %gx
  push(@iparam, 3); # %{3}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, 96); # %{96}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[24]); # %gy
  push(@iparam, 004); # %{004}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 96); # %{96}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[23]); # %gx
  push(@iparam, 128); # %{128}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[23]); # %gx
  push(@iparam, 004); # %{004}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 64); # %{64}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(31); # \\037

  return $rc;
}
',
          '\\E[?7h\\E[?3l\\E[?5h' => '
#
# Stub version of: \\E[?7h\\E[?3l\\E[?5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\0X' => '
#
# Stub version of: \\0X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(88); # X

  return $rc;
}
',
          '\\23324m' => '
#
# Stub version of: \\23324m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EY%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\EY%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[020q' => '
#
# Stub version of: \\E[020q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[?%?%p1%{0}%=%t0%e%p1%{1}%=%t2%e%p1%{1}%-%d%;m' => '
#
# Stub version of: \\E[?%?%p1%{0}%=%t0%e%p1%{1}%=%t2%e%p1%{1}%-%d%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 1); # %{1}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    push(@iparam, 1); # %{1}
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[3%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m' => '
#
# Stub version of: \\E[3%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E_E\\E\\\\' => '
#
# Stub version of: \\E_E\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\377\\210' => '
#
# Stub version of: \\377\\210
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(136); # \\210

  return $rc;
}
',
          '\\E[%?%p2%t4;%;%?%p4%t5;%;%?%p6%t1;%;%?%p1%p3%|%!%t7;%;%?%p7%t8;%;m%?%p9%t\\017%e\\016%;' => '
#
# Stub version of: \\E[%?%p2%t4;%;%?%p4%t5;%;%?%p6%t1;%;%?%p1%p3%|%!%t7;%;%?%p7%t8;%;m%?%p9%t\\017%e\\016%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, ! pop(@iparam)); # %!
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(56); # 8
    $rc .= chr(59); # ;
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(15); # \\017
  }
  else { # %e
    $rc .= chr(14); # \\016
  } # %;

  return $rc;
}
',
          '\\E[>1;5C' => '
#
# Stub version of: \\E[>1;5C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[103z' => '
#
# Stub version of: \\E[103z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\377\\353' => '
#
# Stub version of: \\377\\353
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(235); # \\353

  return $rc;
}
',
          '\\2330u' => '
#
# Stub version of: \\2330u
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\E[?5l\\E[?5h$<200/>' => '
#
# Stub version of: \\E[?5l\\E[?5h$<200/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1t\\E[7m' => '
#
# Stub version of: \\E[1t\\E[7m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(116); # t
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\032$<12/>' => '
#
# Stub version of: \\032$<12/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(26); # \\032
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\2333%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m' => '
#
# Stub version of: \\2333%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[18~' => '
#
# Stub version of: \\E[18~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[%?%p1%{8}%<%t4%p1%e=%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%;%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m' => '
#
# Stub version of: \\E[%?%p1%{8}%<%t4%p1%e=%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%;%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 8); # %{8}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    push(@iparam, $param[0]); # %p1
  }
  else { # %e
    $rc .= chr(61); # =
    push(@iparam, $param[0]); # %p1
    push(@iparam, 2); # %{2}
    push(@iparam, pop(@iparam) & pop(@iparam)); # %&
    if (do { # %?
             push(@iparam, $param[0]); # %p1
             push(@iparam, 1); # %{1}
             push(@iparam, pop(@iparam) & pop(@iparam)); # %&
             pop(@iparam);
           }) { # %t
      push(@iparam, 4); # %{4}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
    if (do { # %?
             push(@iparam, $param[0]); # %p1
             push(@iparam, 4); # %{4}
             push(@iparam, pop(@iparam) & pop(@iparam)); # %&
             pop(@iparam);
           }) { # %t
      push(@iparam, 1); # %{1}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
  } # %;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  if (do { # %?
           push(@iparam, $staticp->[3]); # %gD
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[20]); # %gU
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[1]); # %gB
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[17]); # %gR
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '^V^A^A' => '
#
# Stub version of: ^V^A^A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^A
  $rc .= chr(0); # ^A

  return $rc;
}
',
          '\\376B^A' => '
#
# Stub version of: \\376B^A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(254); # \\376
  $rc .= chr(66); # B
  $rc .= chr(0); # ^A

  return $rc;
}
',
          '\\E[8;0|\\E[?3;4;5;13;15l\\E[13;20l\\E[?7h\\E[12h\\E(B\\E)B' => '
#
# Stub version of: \\E[8;0|\\E[?3;4;5;13;15l\\E[13;20l\\E[?7h\\E[12h\\E(B\\E)B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E^R' => '
#
# Stub version of: \\E^R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^R

  return $rc;
}
',
          '\\Eg\\Ef\\r' => '
#
# Stub version of: \\Eg\\Ef\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Eg\\El' => '
#
# Stub version of: \\Eg\\El
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\Eu\\E0' => '
#
# Stub version of: \\Eu\\E0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\Eb$<200>\\Ed' => '
#
# Stub version of: \\Eb$<200>\\Ed
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\EA11' => '
#
# Stub version of: \\EA11
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[?7h\\E[?1l\\E[?3l\\E7\\E[1;42r\\E8' => '
#
# Stub version of: \\E[?7h\\E[?1l\\E[?3l\\E7\\E[1;42r\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[2A' => '
#
# Stub version of: \\E[2A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E4%{64}%?%p1%t%{65}%|%;%?%p2%t%{66}%|%;%?%p3%t%{65}%|%;%?%p4%t%{68}%|%;%?%p5%t%{64}%|%;%?%p6%t%{72}%|%;%?%p7%t%{80}%|%;%c%?%p9%t\\E>A%e\\E>B%;' => '
#
# Stub version of: \\E4%{64}%?%p1%t%{65}%|%;%?%p2%t%{66}%|%;%?%p3%t%{65}%|%;%?%p4%t%{68}%|%;%?%p5%t%{64}%|%;%?%p6%t%{72}%|%;%?%p7%t%{80}%|%;%c%?%p9%t\\E>A%e\\E>B%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  push(@iparam, 64); # %{64}
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    push(@iparam, 65); # %{65}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    push(@iparam, 66); # %{66}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    push(@iparam, 65); # %{65}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 68); # %{68}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    push(@iparam, 64); # %{64}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    push(@iparam, 72); # %{72}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    push(@iparam, 80); # %{80}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(62); # >
    $rc .= chr(65); # A
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(62); # >
    $rc .= chr(66); # B
  } # %;

  return $rc;
}
',
          'f2' => '
#
# Stub version of: f2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(102); # f
  $rc .= chr(50); # 2

  return $rc;
}
',
          'aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}' => '
#
# Stub version of: aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(121); # y
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(123); # {
  $rc .= chr(123); # {
  $rc .= chr(124); # |
  $rc .= chr(124); # |
  $rc .= chr(125); # }
  $rc .= chr(125); # }

  return $rc;
}
',
          '\\EO2Q' => '
#
# Stub version of: \\EO2Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(50); # 2
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\011$<1>' => '
#
# Stub version of: \\011$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(9); # \\011
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ec\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h' => '
#
# Stub version of: \\Ec\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[%p1%dC$<30>' => '
#
# Stub version of: \\E[%p1%dC$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\2331~' => '
#
# Stub version of: \\2331~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\020\\032\\030\\035$<2/>' => '
#
# Stub version of: \\020\\032\\030\\035$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  $rc .= chr(26); # \\032
  $rc .= chr(24); # \\030
  $rc .= chr(29); # \\035
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[11;4~' => '
#
# Stub version of: \\E[11;4~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[015q' => '
#
# Stub version of: \\E[015q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\Em\\s\\s' => '
#
# Stub version of: \\Em\\s\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(32); # \\s
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E[1;2F' => '
#
# Stub version of: \\E[1;2F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E[19;0j\\E[21;1j\\212' => '
#
# Stub version of: \\E[19;0j\\E[21;1j\\212
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(138); # \\212

  return $rc;
}
',
          '\\E[2J' => '
#
# Stub version of: \\E[2J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[0;%?%p1%{11}%<%t%\'\\:\'%e%?%p1%{13}%<%t%\'z\'%e%?%p1%{23}%<%t%\'G\'%e%?%p1%{25}%<%t%\'p\'%e%?%p1%\'#\'%<%t%\'E\'%e%?%p1%\'%\'%<%t%\'f\'%e%?%p1%\'/\'%<%t%\'C\'%e%{92}%;%;%;%;%;%;%;%p1%+%d;%p2"%s"p' => '
#
# Stub version of: \\E[0;%?%p1%{11}%<%t%\'\\:\'%e%?%p1%{13}%<%t%\'z\'%e%?%p1%{23}%<%t%\'G\'%e%?%p1%{25}%<%t%\'p\'%e%?%p1%\'#\'%<%t%\'E\'%e%?%p1%\'%\'%<%t%\'f\'%e%?%p1%\'/\'%<%t%\'C\'%e%{92}%;%;%;%;%;%;%;%p1%+%d;%p2"%s"p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 11); # %{11}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    push(@iparam, chr(128)); # %\'\\:\'
  }
  else { # %e
    if (do { # %?
             push(@iparam, $param[0]); # %p1
             push(@iparam, 13); # %{13}
             { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
             pop(@iparam);
           }) { # %t
      push(@iparam, chr(122)); # %\'z\'
    }
    else { # %e
      if (do { # %?
               push(@iparam, $param[0]); # %p1
               push(@iparam, 23); # %{23}
               { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
               pop(@iparam);
             }) { # %t
        push(@iparam, chr(71)); # %\'G\'
      }
      else { # %e
        if (do { # %?
                 push(@iparam, $param[0]); # %p1
                 push(@iparam, 25); # %{25}
                 { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
                 pop(@iparam);
               }) { # %t
          push(@iparam, chr(112)); # %\'p\'
        }
        else { # %e
          if (do { # %?
                   push(@iparam, $param[0]); # %p1
                   push(@iparam, chr(35)); # %\'#\'
                   { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
                   pop(@iparam);
                 }) { # %t
            push(@iparam, chr(69)); # %\'E\'
          }
          else { # %e
            if (do { # %?
                     push(@iparam, $param[0]); # %p1
                     push(@iparam, chr(37)); # %\'%\'
                     { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
                     pop(@iparam);
                   }) { # %t
              push(@iparam, chr(102)); # %\'f\'
            }
            else { # %e
              if (do { # %?
                       push(@iparam, $param[0]); # %p1
                       push(@iparam, chr(47)); # %\'/\'
                       { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
                       pop(@iparam);
                     }) { # %t
                push(@iparam, chr(67)); # %\'C\'
              }
              else { # %e
                push(@iparam, 92); # %{92}
              } # %;
            } # %;
          } # %;
        } # %;
      } # %;
    } # %;
  } # %;
  push(@iparam, $param[0]); # %p1
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(34); # "
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(34); # "
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[200z' => '
#
# Stub version of: \\E[200z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[K\\E[m' => '
#
# Stub version of: \\E[K\\E[m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EW' => '
#
# Stub version of: \\EW
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W

  return $rc;
}
',
          '^A?\\r' => '
#
# Stub version of: ^A?\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(63); # ?
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[<0;<1;<2;<4l\\E[5;1v\\E[1;1;126w\\E[1;6;<2h' => '
#
# Stub version of: \\E[<0;<1;<2;<4l\\E[5;1v\\E[1;1;126w\\E[1;6;<2h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\377\\305' => '
#
# Stub version of: \\377\\305
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(197); # \\305

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dH$<5>' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dH$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&a%p2%dc%p1%dY' => '
#
# Stub version of: \\E&a%p2%dc%p1%dY
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(99); # c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(89); # Y

  return $rc;
}
',
          '\\E[=1;%i%p1%dm' => '
#
# Stub version of: \\E[=1;%i%p1%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[5\\^' => '
#
# Stub version of: \\E[5\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\240' => '
#
# Stub version of: \\240
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(160); # \\240

  return $rc;
}
',
          '\\E(%p1%c' => '
#
# Stub version of: \\E(%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\EVS' => '
#
# Stub version of: \\EVS
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\EAAN' => '
#
# Stub version of: \\EAAN
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(65); # A
  $rc .= chr(78); # N

  return $rc;
}
',
          '\\2332m' => '
#
# Stub version of: \\2332m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(109); # m

  return $rc;
}
',
          '^Aw\\r' => '
#
# Stub version of: ^Aw\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(119); # w
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^^D^T' => '
#
# Stub version of: ^^D^T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(68); # D
  $rc .= chr(0); # ^T

  return $rc;
}
',
          '\\ERC' => '
#
# Stub version of: \\ERC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[1;5D' => '
#
# Stub version of: \\E[1;5D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[A$<5/>' => '
#
# Stub version of: \\E[A$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[22~' => '
#
# Stub version of: \\E[22~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\036FP%p1%2.2XFF' => '
#
# Stub version of: \\036FP%p1%2.2XFF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(80); # P
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  $rc .= chr(70); # F
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E9P' => '
#
# Stub version of: \\E9P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[21;0j\\E[25;1j\\212' => '
#
# Stub version of: \\E[21;0j\\E[25;1j\\212
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(138); # \\212

  return $rc;
}
',
          '%?%p1%p3%|%t\\E`6\\E)%e%p5%p8%|%t\\E`7\\E)%e\\E(%;%?%p9%t\\EH\\002%e\\EH\\003%;' => '
#
# Stub version of: %?%p1%p3%|%t\\E`6\\E)%e%p5%p8%|%t\\E`7\\E)%e\\E(%;%?%p9%t\\EH\\002%e\\EH\\003%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(96); # `
    $rc .= chr(54); # 6
    $rc .= chr(27); # \\E
    $rc .= chr(41); # )
  }
  elsif (do { # %e
              push(@iparam, $param[4]); # %p5
              push(@iparam, $param[7]); # %p8
              push(@iparam, pop(@iparam) | pop(@iparam)); # %|
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(96); # `
    $rc .= chr(55); # 7
    $rc .= chr(27); # \\E
    $rc .= chr(41); # )
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(72); # H
    $rc .= chr(2); # \\002
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(72); # H
    $rc .= chr(3); # \\003
  } # %;

  return $rc;
}
',
          '\\EC\\EN\\EX\\024\\016\\EA\\Ea\\E%\\E9\\Ee\\Er\\En\\E"\\E}\\E\'\\E(\\Ef\\r\\EG0\\Ed\\E.4\\El' => '
#
# Stub version of: \\EC\\EN\\EX\\024\\016\\EA\\Ea\\E%\\E9\\Ee\\Er\\En\\E"\\E}\\E\'\\E(\\Ef\\r\\EG0\\Ed\\E.4\\El
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(20); # \\024
  $rc .= chr(14); # \\016
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(97); # a
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(110); # n
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(125); # }
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l

  return $rc;
}
',
          '^B1^J' => '
#
# Stub version of: ^B1^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(49); # 1
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '\\020%p1%{10}%/%{16}%*%p1%{10}%m%+%c' => '
#
# Stub version of: \\020%p1%{10}%/%{16}%*%p1%{10}%m%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  push(@iparam, $param[0]); # %p1
  push(@iparam, 10); # %{10}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 16); # %{16}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, $param[0]); # %p1
  push(@iparam, 10); # %{10}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[H\\E[7m\\E[J' => '
#
# Stub version of: \\E[H\\E[7m\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\217R' => '
#
# Stub version of: \\217R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[%p1%de' => '
#
# Stub version of: \\E[%p1%de
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\E[1T' => '
#
# Stub version of: \\E[1T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\036%?%p1%p3%|%p6%|%tD%eE%;%?%p2%p6%|%t\\024%e\\025%;%?%p4%t\\016%e\\017%;%?%p1%p5%|%t\\034%e\\035%;\\036FS%?%p9%t11%e00%;' => '
#
# Stub version of: \\036%?%p1%p3%|%p6%|%tD%eE%;%?%p2%p6%|%t\\024%e\\025%;%?%p4%t\\016%e\\017%;%?%p1%p5%|%t\\034%e\\035%;\\036FS%?%p9%t11%e00%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(68); # D
  }
  else { # %e
    $rc .= chr(69); # E
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(20); # \\024
  }
  else { # %e
    $rc .= chr(21); # \\025
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(28); # \\034
  }
  else { # %e
    $rc .= chr(29); # \\035
  } # %;
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
    $rc .= chr(49); # 1
  }
  else { # %e
    $rc .= chr(48); # 0
    $rc .= chr(48); # 0
  } # %;

  return $rc;
}
',
          '\\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;12%;m' => '
#
# Stub version of: \\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;12%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(50); # 2
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\ENz' => '
#
# Stub version of: \\ENz
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\ENg' => '
#
# Stub version of: \\ENg
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\217y' => '
#
# Stub version of: \\217y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(121); # y

  return $rc;
}
',
          '\\377\\0' => '
#
# Stub version of: \\377\\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(128); # \\0

  return $rc;
}
',
          '\\EO1;7C' => '
#
# Stub version of: \\EO1;7C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E\\023\\E@' => '
#
# Stub version of: \\E\\023\\E@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  $rc .= chr(27); # \\E
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\EO5B' => '
#
# Stub version of: \\EO5B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(53); # 5
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\2331$}\\2332$~\\n\\2330$}' => '
#
# Stub version of: \\2331$}\\2332$~\\n\\2330$}
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(125); # }
  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(126); # ~
  $rc .= chr(10); # \\n
  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(125); # }

  return $rc;
}
',
          '\\EG0\\EH\\003$<15>' => '
#
# Stub version of: \\EG0\\EH\\003$<15>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(3); # \\003
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[15\\^' => '
#
# Stub version of: \\E[15\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\377\\241' => '
#
# Stub version of: \\377\\241
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(161); # \\241

  return $rc;
}
',
          '\\E[4%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m' => '
#
# Stub version of: \\E[4%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[19;2~' => '
#
# Stub version of: \\E[19;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^Oo' => '
#
# Stub version of: ^Oo
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^O
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\Ec\\E[12;31h\\E[?3;4;5;10l\\E[?6;7;19;25h\\E[33;34l\\E[0m\\E(B\\E)0\\E%/0n\\E[P\\031$<200>' => '
#
# Stub version of: \\Ec\\E[12;31h\\E[?3;4;5;10l\\E[?6;7;19;25h\\E[33;34l\\E[0m\\E(B\\E)0\\E%/0n\\E[P\\031$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= chr(48); # 0
  $rc .= chr(110); # n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(80); # P
  $rc .= chr(25); # \\031
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Er%i%p1%d;' => '
#
# Stub version of: \\Er%i%p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E7\\E[r\\E8\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h' => '
#
# Stub version of: \\E7\\E[r\\E8\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\013@\\E^E00' => '
#
# Stub version of: \\013@\\E^E00
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E\\003\\E1' => '
#
# Stub version of: \\E\\003\\E1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\Ec\\E)0' => '
#
# Stub version of: \\Ec\\E)0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E*0' => '
#
# Stub version of: \\E*0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[1;4P' => '
#
# Stub version of: \\E[1;4P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\Ec\\E[?7h' => '
#
# Stub version of: \\Ec\\E[?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EC\\EX\\Eg\\En\\E%\\Er\\E(\\Ek\\Em\\Eq' => '
#
# Stub version of: \\EC\\EX\\Eg\\En\\E%\\Er\\E(\\Ek\\Em\\Eq
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(110); # n
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p1%t;3%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p1%t;3%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(51); # 3
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          'O\\333a\\261j\\331k\\277l\\332m\\300n\\305o\\337q\\304s\\334t\\303u\\264v\\301w\\302x\\263' => '
#
# Stub version of: O\\333a\\261j\\331k\\277l\\332m\\300n\\305o\\337q\\304s\\334t\\303u\\264v\\301w\\302x\\263
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(79); # O
  $rc .= chr(219); # \\333
  $rc .= chr(97); # a
  $rc .= chr(177); # \\261
  $rc .= chr(106); # j
  $rc .= chr(217); # \\331
  $rc .= chr(107); # k
  $rc .= chr(191); # \\277
  $rc .= chr(108); # l
  $rc .= chr(218); # \\332
  $rc .= chr(109); # m
  $rc .= chr(192); # \\300
  $rc .= chr(110); # n
  $rc .= chr(197); # \\305
  $rc .= chr(111); # o
  $rc .= chr(223); # \\337
  $rc .= chr(113); # q
  $rc .= chr(196); # \\304
  $rc .= chr(115); # s
  $rc .= chr(220); # \\334
  $rc .= chr(116); # t
  $rc .= chr(195); # \\303
  $rc .= chr(117); # u
  $rc .= chr(180); # \\264
  $rc .= chr(118); # v
  $rc .= chr(193); # \\301
  $rc .= chr(119); # w
  $rc .= chr(194); # \\302
  $rc .= chr(120); # x
  $rc .= chr(179); # \\263

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dr$<2>' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dr$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(114); # r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?~' => '
#
# Stub version of: \\E[?~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E?g' => '
#
# Stub version of: \\E?g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\E3' => '
#
# Stub version of: \\E3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[1L' => '
#
# Stub version of: \\E[1L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\E&a%p1%dC' => '
#
# Stub version of: \\E&a%p1%dC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\377\\277' => '
#
# Stub version of: \\377\\277
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(191); # \\277

  return $rc;
}
',
          '\\E[0;5m' => '
#
# Stub version of: \\E[0;5m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\036HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH\\037' => '
#
# Stub version of: \\036HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH\\037
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(31); # \\037

  return $rc;
}
',
          '\\016$<2>' => '
#
# Stub version of: \\016$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\2332J' => '
#
# Stub version of: \\2332J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\005%p1%d;%p2%d;' => '
#
# Stub version of: \\005%p1%d;%p2%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(5); # \\005
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\EB$<2/>' => '
#
# Stub version of: \\EB$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(66); # B
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E%!1' => '
#
# Stub version of: \\E%!1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[109z' => '
#
# Stub version of: \\E[109z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\377\\271' => '
#
# Stub version of: \\377\\271
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(185); # \\271

  return $rc;
}
',
          '\\E[32~' => '
#
# Stub version of: \\E[32~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[%p1%d;%p2%l%d;3;0p   F%p1%d           %p2%s' => '
#
# Stub version of: \\E[%p1%d;%p2%l%d;3;0p   F%p1%d           %p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\E\\^$<50>' => '
#
# Stub version of: \\E\\^$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\'P' => '
#
# Stub version of: \\E\'P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E%!0\\ELBB2\\E%!1' => '
#
# Stub version of: \\E%!0\\ELBB2\\E%!1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(66); # B
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E6$' => '
#
# Stub version of: \\E6$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(54); # 6
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\E!W' => '
#
# Stub version of: \\E!W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\23311~' => '
#
# Stub version of: \\23311~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(126); # ~

  return $rc;
}
',
          '~^T' => '
#
# Stub version of: ~^T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(0); # ^T

  return $rc;
}
',
          '^\\039\\r' => '
#
# Stub version of: ^\\039\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(128); # \\0
  $rc .= chr(51); # 3
  $rc .= chr(57); # 9
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EFW' => '
#
# Stub version of: \\EFW
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\Ex$<16/>' => '
#
# Stub version of: \\Ex$<16/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[j' => '
#
# Stub version of: \\E[j
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(106); # j

  return $rc;
}
',
          '\\E[6n' => '
#
# Stub version of: \\E[6n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\233?3h' => '
#
# Stub version of: \\233?3h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\2330$}\\233?25h\\2332l\\233H\\233J' => '
#
# Stub version of: \\2330$}\\233?25h\\2332l\\233H\\233J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(125); # }
  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(155); # \\233
  $rc .= chr(72); # H
  $rc .= chr(155); # \\233
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[024q' => '
#
# Stub version of: \\E[024q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\EU\\E z"\\Ev\\177 !p\\E ;"\\E z \\Ev  \\001 p\\Ep\\n' => '
#
# Stub version of: \\EU\\E z"\\Ev\\177 !p\\E ;"\\E z \\Ev  \\001 p\\Ep\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(122); # z
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(127); # \\177
  $rc .= chr(32); #  
  $rc .= chr(33); # !
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(59); # ;
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(122); # z
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(1); # \\001
  $rc .= chr(32); #  
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\EA' => '
#
# Stub version of: \\EA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\376K\\376T' => '
#
# Stub version of: \\376K\\376T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(254); # \\376
  $rc .= chr(75); # K
  $rc .= chr(254); # \\376
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\233209z' => '
#
# Stub version of: \\233209z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E&d%{0}%Pa%?%p4%t%{1}%ga%+%Pa%;%?%p1%p3%|%p6%|%t%{2}%ga%+%Pa%;%?%p2%p6%|%t%{4}%ga%+%Pa%;%?%p1%p5%|%t%{8}%ga%+%Pa%;%?%p7%t%?%ga%ts%ga%{64}%+%e%{83}%;%e%?%ga%t%ga%{64}%+%e%{64}%;%;%c%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E&d%{0}%Pa%?%p4%t%{1}%ga%+%Pa%;%?%p1%p3%|%p6%|%t%{2}%ga%+%Pa%;%?%p2%p6%|%t%{4}%ga%+%Pa%;%?%p1%p5%|%t%{8}%ga%+%Pa%;%?%p7%t%?%ga%ts%ga%{64}%+%e%{83}%;%e%?%ga%t%ga%{64}%+%e%{64}%;%;%c%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  push(@iparam, 0); # %{0}
  $dynamicp->[0] = pop(@iparam); # %Pa
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, $dynamicp->[0]); # %ga
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $dynamicp->[0] = pop(@iparam); # %Pa
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
    push(@iparam, $dynamicp->[0]); # %ga
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $dynamicp->[0] = pop(@iparam); # %Pa
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, $dynamicp->[0]); # %ga
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $dynamicp->[0] = pop(@iparam); # %Pa
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 8); # %{8}
    push(@iparam, $dynamicp->[0]); # %ga
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $dynamicp->[0] = pop(@iparam); # %Pa
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    if (do { # %?
             push(@iparam, $dynamicp->[0]); # %ga
             pop(@iparam);
           }) { # %t
      $rc .= chr(115); # s
      push(@iparam, $dynamicp->[0]); # %ga
      push(@iparam, 64); # %{64}
      push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    }
    else { # %e
      push(@iparam, 83); # %{83}
    } # %;
  }
  else { # %e
    if (do { # %?
             push(@iparam, $dynamicp->[0]); # %ga
             pop(@iparam);
           }) { # %t
      push(@iparam, $dynamicp->[0]); # %ga
      push(@iparam, 64); # %{64}
      push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    }
    else { # %e
      push(@iparam, 64); # %{64}
    } # %;
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\EFE' => '
#
# Stub version of: \\EFE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\E[15;3~' => '
#
# Stub version of: \\E[15;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E' => '
#
# Stub version of: \\E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E

  return $rc;
}
',
          '\\E[?6c' => '
#
# Stub version of: \\E[?6c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\233%i%p1%d;%p2%dH' => '
#
# Stub version of: \\233%i%p1%d;%p2%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\Ej\\EY8 \\EI\\Ek' => '
#
# Stub version of: \\Ej\\EY8 \\EI\\Ek
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(56); # 8
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\EOj' => '
#
# Stub version of: \\EOj
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(106); # j

  return $rc;
}
',
          '\\E[8p' => '
#
# Stub version of: \\E[8p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E4 "@' => '
#
# Stub version of: \\E4 "@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(32); #  
  $rc .= chr(34); # "
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[23@' => '
#
# Stub version of: \\E[23@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[3z' => '
#
# Stub version of: \\E[3z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EG%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\EG%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[?47l\\E>\\E[?1l' => '
#
# Stub version of: \\E[?47l\\E>\\E[?1l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E\\017\\E\\:' => '
#
# Stub version of: \\E\\017\\E\\:
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\:

  return $rc;
}
',
          '\\E1  \\030\\002\\003\\017' => '
#
# Stub version of: \\E1  \\030\\002\\003\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(24); # \\030
  $rc .= chr(2); # \\002
  $rc .= chr(3); # \\003
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\210' => '
#
# Stub version of: \\210
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(136); # \\210

  return $rc;
}
',
          '-PAGE' => '
#
# Stub version of: -PAGE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(45); # -
  $rc .= chr(80); # P
  $rc .= chr(65); # A
  $rc .= chr(71); # G
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\377\\255' => '
#
# Stub version of: \\377\\255
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(173); # \\255

  return $rc;
}
',
          '\\014$<40>' => '
#
# Stub version of: \\014$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '%p1%c\\E[%p2%{1}%-%db' => '
#
# Stub version of: %p1%c\\E[%p2%{1}%-%db
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[1]); # %p2
  push(@iparam, 1); # %{1}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\377\\236' => '
#
# Stub version of: \\377\\236
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(158); # \\236

  return $rc;
}
',
          '\\E&dA' => '
#
# Stub version of: \\E&dA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[1t' => '
#
# Stub version of: \\E[1t
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\E7\\E[25;%i%p1%dx' => '
#
# Stub version of: \\E7\\E[25;%i%p1%dx
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\E[u\\E[>5l' => '
#
# Stub version of: \\E[u\\E[>5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '^^K' => '
#
# Stub version of: ^^K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\r$<10*/>' => '
#
# Stub version of: \\r$<10*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[6w' => '
#
# Stub version of: \\E[6w
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\E%!0\\ELBG8\\E%!1\\E[34;1H' => '
#
# Stub version of: \\E%!0\\ELBG8\\E%!1\\E[34;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(71); # G
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\s^_' => '
#
# Stub version of: \\s^_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(32); # \\s
  $rc .= chr(0); # ^_

  return $rc;
}
',
          '\\E<\\E[1;24r\\E[24;1H\\E[?7h\\E[>2h\\E[>1;3;4;5;6;7;8;9l\\E[m\\E[11m' => '
#
# Stub version of: \\E<\\E[1;24r\\E[24;1H\\E[?7h\\E[>2h\\E[>1;3;4;5;6;7;8;9l\\E[m\\E[11m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EOG' => '
#
# Stub version of: \\EOG
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\E[60w\\E[63;0w\\E[66;1;4w\\E[66;2;13w\\E[66;3;16w\\E[66;4;49w\\E[66;5;51w\\E[66;6;61w\\E[66;7;64w' => '
#
# Stub version of: \\E[60w\\E[63;0w\\E[66;1;4w\\E[66;2;13w\\E[66;3;16w\\E[66;4;49w\\E[66;5;51w\\E[66;6;61w\\E[66;7;64w
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(49); # 1
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(49); # 1
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(52); # 4
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\E[c' => '
#
# Stub version of: \\E[c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E[1;7H' => '
#
# Stub version of: \\E[1;7H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E"\\E%\\E\'\\E(\\EG@\\EO\\EX\\E[=5l\\E[=6l\\E[=7h\\Ed\\Er' => '
#
# Stub version of: \\E"\\E%\\E\'\\E(\\EG@\\EO\\EX\\E[=5l\\E[=6l\\E[=7h\\Ed\\Er
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E@%p1%Pf%gb%gf%d%d' => '
#
# Stub version of: \\E@%p1%Pf%gb%gf%d%d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(64); # @
  push(@iparam, $param[0]); # %p1
  $dynamicp->[5] = pop(@iparam); # %Pf
  push(@iparam, $dynamicp->[1]); # %gb
  push(@iparam, $dynamicp->[5]); # %gf
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d

  return $rc;
}
',
          '\\E[15r' => '
#
# Stub version of: \\E[15r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E3!1' => '
#
# Stub version of: \\E3!1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(33); # !
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dH$<10>' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dH$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Em0%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\Em0%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(48); # 0
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\EFp' => '
#
# Stub version of: \\EFp
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\Eh\\r' => '
#
# Stub version of: \\Eh\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(104); # h
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E4n' => '
#
# Stub version of: \\E4n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(110); # n

  return $rc;
}
',
          '++\\,\\,--..``aaffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~' => '
#
# Stub version of: ++\\,\\,--..``aaffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(43); # +
  $rc .= chr(128); # \\,
  $rc .= chr(128); # \\,
  $rc .= chr(45); # -
  $rc .= chr(45); # -
  $rc .= chr(46); # .
  $rc .= chr(46); # .
  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(104); # h
  $rc .= chr(104); # h
  $rc .= chr(105); # i
  $rc .= chr(105); # i
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(121); # y
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(123); # {
  $rc .= chr(123); # {
  $rc .= chr(124); # |
  $rc .= chr(124); # |
  $rc .= chr(125); # }
  $rc .= chr(125); # }
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\23312~' => '
#
# Stub version of: \\23312~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\233020z' => '
#
# Stub version of: \\233020z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E&jA' => '
#
# Stub version of: \\E&jA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(106); # j
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\EFi' => '
#
# Stub version of: \\EFi
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E[%?%p3%t7;%;%?%p4%t5;%;%?%p2%t4;%;%?%p6%t4;7;%;%?%p1%t2;7;%;%?%p5%t2;%;m\\E)%?%p9%t6\\016%e4\\017%;' => '
#
# Stub version of: \\E[%?%p3%t7;%;%?%p4%t5;%;%?%p2%t4;%;%?%p6%t4;7;%;%?%p1%t2;7;%;%?%p5%t2;%;m\\E)%?%p9%t6\\016%e4\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
  } # %;
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(52); # 4
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\E^K' => '
#
# Stub version of: \\E^K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^K

  return $rc;
}
',
          '\\Ea\\r' => '
#
# Stub version of: \\Ea\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(97); # a
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^^d' => '
#
# Stub version of: ^^d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(100); # d

  return $rc;
}
',
          '^A@\\r' => '
#
# Stub version of: ^A@\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(64); # @
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\ET$<8>' => '
#
# Stub version of: \\ET$<8>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EKA1\\ELL5\\ELV0\\ELV1' => '
#
# Stub version of: \\EKA1\\ELL5\\ELV0\\ELV1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(65); # A
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(76); # L
  $rc .= chr(53); # 5
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(86); # V
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(86); # V
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E<\\E[?3l\\E[!p\\E[?7h' => '
#
# Stub version of: \\E<\\E[?3l\\E[!p\\E[?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\233%p1%dT' => '
#
# Stub version of: \\233%p1%dT
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(84); # T

  return $rc;
}
',
          '^^^RY' => '
#
# Stub version of: ^^^RY
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(0); # ^R
  $rc .= chr(89); # Y

  return $rc;
}
',
          '\\E[6C' => '
#
# Stub version of: \\E[6C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E~R' => '
#
# Stub version of: \\E~R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\Ed`' => '
#
# Stub version of: \\Ed`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(96); # `

  return $rc;
}
',
          '\\23317~' => '
#
# Stub version of: \\23317~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\037rig\\r' => '
#
# Stub version of: \\037rig\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(114); # r
  $rc .= chr(105); # i
  $rc .= chr(103); # g
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[L$<2>' => '
#
# Stub version of: \\E[L$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EFL' => '
#
# Stub version of: \\EFL
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\ENR' => '
#
# Stub version of: \\ENR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[1;4C' => '
#
# Stub version of: \\E[1;4C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[%p1%dM$<3*>' => '
#
# Stub version of: \\E[%p1%dM$<3*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%p1%ds\\E[%p1%dD' => '
#
# Stub version of: \\E[%p1%ds\\E[%p1%dD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E7\\E[r\\E8\\E[m\\E[?7h\\E[?1;4;6l\\E[4l\\E>' => '
#
# Stub version of: \\E7\\E[r\\E8\\E[m\\E[?7h\\E[?1;4;6l\\E[4l\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E7\\E[60;0;0;40p\\E8' => '
#
# Stub version of: \\E7\\E[60;0;0;40p\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[4l' => '
#
# Stub version of: \\E[4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\ED$<5/>' => '
#
# Stub version of: \\ED$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^9' => '
#
# Stub version of: ^^9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\Es0' => '
#
# Stub version of: \\Es0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\2337;2m' => '
#
# Stub version of: \\2337;2m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(109); # m

  return $rc;
}
',
          '^V^Ap' => '
#
# Stub version of: ^V^Ap
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^A
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\EOs' => '
#
# Stub version of: \\EOs
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\Eb\\E[?<h' => '
#
# Stub version of: \\Eb\\E[?<h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(60); # <
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\022$<3>' => '
#
# Stub version of: \\022$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(18); # \\022
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '^_"' => '
#
# Stub version of: ^_"
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^_
  $rc .= chr(34); # "

  return $rc;
}
',
          '\\n$<280>' => '
#
# Stub version of: \\n$<280>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E)\\Ej' => '
#
# Stub version of: \\E)\\Ej
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(27); # \\E
  $rc .= chr(106); # j

  return $rc;
}
',
          '\\E[4m$<2/>' => '
#
# Stub version of: \\E[4m$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E~k<10*>' => '
#
# Stub version of: \\E~k<10*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(107); # k
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[!p\\E[?7h\\E[2;1;1#w' => '
#
# Stub version of: \\E[!p\\E[?7h\\E[2;1;1#w
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(35); # #
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\EC\\E3 \\E3(' => '
#
# Stub version of: \\EC\\E3 \\E3(
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(40); # (

  return $rc;
}
',
          '\\014%p2%{96}%^%c%p1%{96}%^%c' => '
#
# Stub version of: \\014%p2%{96}%^%c%p1%{96}%^%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  push(@iparam, $param[1]); # %p2
  push(@iparam, 96); # %{96}
  push(@iparam, pop(@iparam) ^ pop(@iparam)); # %^
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 96); # %{96}
  push(@iparam, pop(@iparam) ^ pop(@iparam)); # %^
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          'PF6' => '
#
# Stub version of: PF6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(80); # P
  $rc .= chr(70); # F
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E[%p1%d`' => '
#
# Stub version of: \\E[%p1%d`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(96); # `

  return $rc;
}
',
          '%?%gB%{0}%=%t\\E&dB%{1}%PB%;' => '
#
# Stub version of: %?%gB%{0}%=%t\\E&dB%{1}%PB%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $staticp->[1]); # %gB
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(100); # d
    $rc .= chr(66); # B
    push(@iparam, 1); # %{1}
    $staticp->[1] = pop(@iparam); # %PB
  } # %;

  return $rc;
}
',
          '\\E)0\\E[r\\017' => '
#
# Stub version of: \\E)0\\E[r\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\E<\\E[?3l$<100>' => '
#
# Stub version of: \\E<\\E[?3l$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO\\s' => '
#
# Stub version of: \\EO\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E[?12;25h' => '
#
# Stub version of: \\E[?12;25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[14;3~' => '
#
# Stub version of: \\E[14;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\ET\\EG0\\010\\Eg0' => '
#
# Stub version of: \\ET\\EG0\\010\\Eg0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[%?%p1%{0}%=%t30m%e%p1%{1}%=%t31m%e%p1%{2}%=%t32m%e%p1%{3}%=%t33m%e%p1%{4}%=%t34m%e%p1%{5}%=%t35m%e%p1%{6}%=%t36m%e%p1%{7}%=%t97m%;' => '
#
# Stub version of: \\E[%?%p1%{0}%=%t30m%e%p1%{1}%=%t31m%e%p1%{2}%=%t32m%e%p1%{3}%=%t33m%e%p1%{4}%=%t34m%e%p1%{5}%=%t35m%e%p1%{6}%=%t36m%e%p1%{7}%=%t97m%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
    $rc .= chr(48); # 0
    $rc .= chr(109); # m
  } # %;
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 1); # %{1}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
    $rc .= chr(49); # 1
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 2); # %{2}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
    $rc .= chr(50); # 2
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
    $rc .= chr(51); # 3
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
    $rc .= chr(52); # 4
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 5); # %{5}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
    $rc .= chr(53); # 5
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
    $rc .= chr(54); # 6
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 7); # %{7}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(57); # 9
    $rc .= chr(55); # 7
    $rc .= chr(109); # m
  }

  return $rc;
}
',
          '\\E[H\\E[J$<156/>' => '
#
# Stub version of: \\E[H\\E[J$<156/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[8u\\027' => '
#
# Stub version of: \\E[8u\\027
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(117); # u
  $rc .= chr(23); # \\027

  return $rc;
}
',
          '\\E3\\E\\001\\E\\007\\E\\003\\Ek\\EG\\Ed\\EX\\El\\E>\\Eb\\E\\\\' => '
#
# Stub version of: \\E3\\E\\001\\E\\007\\E\\003\\Ek\\EG\\Ed\\EX\\El\\E>\\Eb\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(7); # \\007
  $rc .= chr(27); # \\E
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E#>' => '
#
# Stub version of: \\E#>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%{1}%p1%+%ds' => '
#
# Stub version of: \\E[%{1}%p1%+%ds
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, 1); # %{1}
  push(@iparam, $param[0]); # %p1
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\EOv' => '
#
# Stub version of: \\EOv
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\E%?' => '
#
# Stub version of: \\E%?
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  # IF/ENDIF ignored
  return $rc;
}
',
          '\\035%{3040}%{89}%p1%*%-%Py%p2%{55}%*%Px%gy%{128}%/%{31}%&%{32}%+%c%gy%{3}%&%{4}%*%gx%{3}%&%+%{96}%+%c%gy%{004}%/%{31}%&%{96}%+%c%gx%{128}%/%{31}%&%{32}%+%c%gx%{004}%/%{31}%&%{64}%+%c\\037' => '
#
# Stub version of: \\035%{3040}%{89}%p1%*%-%Py%p2%{55}%*%Px%gy%{128}%/%{31}%&%{32}%+%c%gy%{3}%&%{4}%*%gx%{3}%&%+%{96}%+%c%gy%{004}%/%{31}%&%{96}%+%c%gx%{128}%/%{31}%&%{32}%+%c%gx%{004}%/%{31}%&%{64}%+%c\\037
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  push(@iparam, 3040); # %{3040}
  push(@iparam, 89); # %{89}
  push(@iparam, $param[0]); # %p1
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  $dynamicp->[24] = pop(@iparam); # %Py
  push(@iparam, $param[1]); # %p2
  push(@iparam, 55); # %{55}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  $dynamicp->[23] = pop(@iparam); # %Px
  push(@iparam, $dynamicp->[24]); # %gy
  push(@iparam, 128); # %{128}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[24]); # %gy
  push(@iparam, 3); # %{3}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 4); # %{4}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, $dynamicp->[23]); # %gx
  push(@iparam, 3); # %{3}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, 96); # %{96}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[24]); # %gy
  push(@iparam, 004); # %{004}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 96); # %{96}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[23]); # %gx
  push(@iparam, 128); # %{128}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[23]); # %gx
  push(@iparam, 004); # %{004}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 64); # %{64}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(31); # \\037

  return $rc;
}
',
          '^^#' => '
#
# Stub version of: ^^#
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(35); # #

  return $rc;
}
',
          '\\E!b\\r' => '
#
# Stub version of: \\E!b\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(98); # b
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[11~' => '
#
# Stub version of: \\E[11~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^]\\344' => '
#
# Stub version of: ^]\\344
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^]
  $rc .= chr(228); # \\344

  return $rc;
}
',
          '\\377\\341' => '
#
# Stub version of: \\377\\341
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(225); # \\341

  return $rc;
}
',
          '\\Eb^A' => '
#
# Stub version of: \\Eb^A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(0); # ^A

  return $rc;
}
',
          '\\ELZ\\EKA0' => '
#
# Stub version of: \\ELZ\\EKA0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(90); # Z
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(65); # A
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\233T' => '
#
# Stub version of: \\233T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\E[>1;2A' => '
#
# Stub version of: \\E[>1;2A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\Ev\\Eq\\Ee' => '
#
# Stub version of: \\Ev\\Eq\\Ee
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\Ex' => '
#
# Stub version of: \\Ex
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\233?7h\\233>\\233?1l\\E F\\233?4l' => '
#
# Stub version of: \\233?7h\\233>\\233?1l\\E F\\233?4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(155); # \\233
  $rc .= chr(62); # >
  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '~^L' => '
#
# Stub version of: ~^L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(0); # ^L

  return $rc;
}
',
          '\\E>\\017\\E)0\\E(B\\E[63;0w\\E[m' => '
#
# Stub version of: \\E>\\017\\E)0\\E(B\\E[63;0w\\E[m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m

  return $rc;
}
',
          '3' => '
#
# Stub version of: 3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[3s' => '
#
# Stub version of: \\E[3s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\EsB' => '
#
# Stub version of: \\EsB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\ESTART\\r\\E78\\r\\E70\\,0\\r\\EEND\\r$<20>' => '
#
# Stub version of: \\ESTART\\r\\E78\\r\\E70\\,0\\r\\EEND\\r$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(84); # T
  $rc .= chr(65); # A
  $rc .= chr(82); # R
  $rc .= chr(84); # T
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(56); # 8
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(78); # N
  $rc .= chr(68); # D
  $rc .= chr(13); # \\r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ef3' => '
#
# Stub version of: \\Ef3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\El' => '
#
# Stub version of: \\El
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[224z' => '
#
# Stub version of: \\E[224z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '^^R' => '
#
# Stub version of: ^^R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[?3l\\E)0\\E(B' => '
#
# Stub version of: \\E[?3l\\E)0\\E(B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\EU\\Ev  8p\\Ep\\r\\E\\025' => '
#
# Stub version of: \\EU\\Ev  8p\\Ep\\r\\E\\025
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(56); # 8
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(21); # \\025

  return $rc;
}
',
          '\\E[?20l\\E[?7h\\E[1Q' => '
#
# Stub version of: \\E[?20l\\E[?7h\\E[1Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\ER$<1.5*>' => '
#
# Stub version of: \\ER$<1.5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0m\\017\\E[30;85;>15m' => '
#
# Stub version of: \\E[0m\\017\\E[30;85;>15m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[?25h\\E[?0c' => '
#
# Stub version of: \\E[?25h\\E[?0c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(48); # 0
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E[%p1%d@$<1*>' => '
#
# Stub version of: \\E[%p1%d@$<1*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(64); # @
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\,' => '
#
# Stub version of: \\E\\,
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\,

  return $rc;
}
',
          '\\014$<5*/>' => '
#
# Stub version of: \\014$<5*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;$<2>' => '
#
# Stub version of: \\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ER$<5>' => '
#
# Stub version of: \\ER$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E%!0\\ETD10\\E%!1' => '
#
# Stub version of: \\E%!0\\ETD10\\E%!1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(68); # D
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\EO7C' => '
#
# Stub version of: \\EO7C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(55); # 7
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[P$<40>' => '
#
# Stub version of: \\E[P$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\246' => '
#
# Stub version of: \\377\\246
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(166); # \\246

  return $rc;
}
',
          '\\Ev    $<6>\\Ep\\n' => '
#
# Stub version of: \\Ev    $<6>\\Ep\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\E[H\\E[A' => '
#
# Stub version of: \\E[H\\E[A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\Ef\\r' => '
#
# Stub version of: \\Ef\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[12;3~' => '
#
# Stub version of: \\E[12;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p4%t;5%;%?%p1%p3%|%t;7%;m%?%p9%t\\E(0%e\\E(B%;$<2>' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p4%t;5%;%?%p1%p3%|%t;7%;m%?%p9%t\\E(0%e\\E(B%;$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\036FG\\036PA' => '
#
# Stub version of: \\036FG\\036PA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(71); # G
  $rc .= chr(30); # \\036
  $rc .= chr(80); # P
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[1s' => '
#
# Stub version of: \\E[1s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\EO6C' => '
#
# Stub version of: \\EO6C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(54); # 6
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\020%p2%c%p1%c' => '
#
# Stub version of: \\020%p2%c%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[x\\E[J' => '
#
# Stub version of: \\E[x\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(120); # x
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[1;23r\\E[23;1H' => '
#
# Stub version of: \\E[1;23r\\E[23;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E\\001\\E2' => '
#
# Stub version of: \\E\\001\\E2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\376L' => '
#
# Stub version of: \\376L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(254); # \\376
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\377\\211' => '
#
# Stub version of: \\377\\211
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(137); # \\211

  return $rc;
}
',
          '\\Ey$<5>' => '
#
# Stub version of: \\Ey$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\036B%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%{48}%+%c' => '
#
# Stub version of: \\036B%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%{48}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(66); # B
  push(@iparam, $param[0]); # %p1
  push(@iparam, 2); # %{2}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 4); # %{4}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[312z' => '
#
# Stub version of: \\E[312z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '^\\019\\r' => '
#
# Stub version of: ^\\019\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(128); # \\0
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E`b' => '
#
# Stub version of: \\E`b
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(98); # b

  return $rc;
}
',
          '^P' => '
#
# Stub version of: ^P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P

  return $rc;
}
',
          '\\E!i\\r' => '
#
# Stub version of: \\E!i\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(105); # i
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E.3' => '
#
# Stub version of: \\E.3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[H\\E[J$<200>' => '
#
# Stub version of: \\E[H\\E[J$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ER$<3>' => '
#
# Stub version of: \\ER$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO1;4R' => '
#
# Stub version of: \\EO1;4R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\377\\340' => '
#
# Stub version of: \\377\\340
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(224); # \\340

  return $rc;
}
',
          '^V^N' => '
#
# Stub version of: ^V^N
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^N

  return $rc;
}
',
          '\\EL$<6*/>' => '
#
# Stub version of: \\EL$<6*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E7\\E[99;0H\\E[K\\E8' => '
#
# Stub version of: \\E7\\E[99;0H\\E[K\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\036B%p1%{48}%+%c' => '
#
# Stub version of: \\036B%p1%{48}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(66); # B
  push(@iparam, $param[0]); # %p1
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E&dD\\E&v1S' => '
#
# Stub version of: \\E&dD\\E&v1S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(68); # D
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(49); # 1
  $rc .= chr(83); # S

  return $rc;
}
',
          '%?%p9%t\\E(0%e\\E(B%;\\E[0%?%p5%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p1%p3%|%t;7%;m' => '
#
# Stub version of: %?%p9%t\\E(0%e\\E(B%;\\E[0%?%p5%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p1%p3%|%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[32h\\E[?5h' => '
#
# Stub version of: \\E[32h\\E[?5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[H\\E[J\\E[V' => '
#
# Stub version of: \\E[H\\E[J\\E[V
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(86); # V

  return $rc;
}
',
          '\\010$<5>' => '
#
# Stub version of: \\010$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(8); # \\010
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[A$<2>' => '
#
# Stub version of: \\E[A$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[31l$<25>' => '
#
# Stub version of: \\E[31l$<25>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '^A3\\r' => '
#
# Stub version of: ^A3\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(51); # 3
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[K$<4/>' => '
#
# Stub version of: \\E[K$<4/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[3%p1%\'0\'%+%Pa%?%ga%\'0\'%=%t0%e%ga%\'1\'%=%t4%e%ga%\'2\'%=%t2%e%ga%\'3\'%=%t6%e%ga%\'4\'%=%t1%e%ga%\'5\'%=%t5%e%ga%\'6\'%=%t3%e7%;m' => '
#
# Stub version of: \\E[3%p1%\'0\'%+%Pa%?%ga%\'0\'%=%t0%e%ga%\'1\'%=%t4%e%ga%\'2\'%=%t2%e%ga%\'3\'%=%t6%e%ga%\'4\'%=%t1%e%ga%\'5\'%=%t5%e%ga%\'6\'%=%t3%e7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  push(@iparam, $param[0]); # %p1
  push(@iparam, chr(48)); # %\'0\'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $dynamicp->[0] = pop(@iparam); # %Pa
  if (do { # %?
           push(@iparam, $dynamicp->[0]); # %ga
           push(@iparam, chr(48)); # %\'0\'
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, chr(49)); # %\'1\'
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, chr(50)); # %\'2\'
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, chr(51)); # %\'3\'
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, chr(52)); # %\'4\'
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, chr(53)); # %\'5\'
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, chr(54)); # %\'6\'
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
  }
  else { # %e
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[0L' => '
#
# Stub version of: \\E[0L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\377\\257' => '
#
# Stub version of: \\377\\257
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(175); # \\257

  return $rc;
}
',
          '-\\030.^Y0\\215`\\004a\\220f\\234h\\221i\\025j\\205k\\203l\\202m\\204n\\212q\\0t\\206u\\207v\\211w\\210x\\201y\\230z\\231~\\225' => '
#
# Stub version of: -\\030.^Y0\\215`\\004a\\220f\\234h\\221i\\025j\\205k\\203l\\202m\\204n\\212q\\0t\\206u\\207v\\211w\\210x\\201y\\230z\\231~\\225
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(45); # -
  $rc .= chr(24); # \\030
  $rc .= chr(46); # .
  $rc .= chr(0); # ^Y
  $rc .= chr(48); # 0
  $rc .= chr(141); # \\215
  $rc .= chr(96); # `
  $rc .= chr(4); # \\004
  $rc .= chr(97); # a
  $rc .= chr(144); # \\220
  $rc .= chr(102); # f
  $rc .= chr(156); # \\234
  $rc .= chr(104); # h
  $rc .= chr(145); # \\221
  $rc .= chr(105); # i
  $rc .= chr(21); # \\025
  $rc .= chr(106); # j
  $rc .= chr(133); # \\205
  $rc .= chr(107); # k
  $rc .= chr(131); # \\203
  $rc .= chr(108); # l
  $rc .= chr(130); # \\202
  $rc .= chr(109); # m
  $rc .= chr(132); # \\204
  $rc .= chr(110); # n
  $rc .= chr(138); # \\212
  $rc .= chr(113); # q
  $rc .= chr(128); # \\0
  $rc .= chr(116); # t
  $rc .= chr(134); # \\206
  $rc .= chr(117); # u
  $rc .= chr(135); # \\207
  $rc .= chr(118); # v
  $rc .= chr(137); # \\211
  $rc .= chr(119); # w
  $rc .= chr(136); # \\210
  $rc .= chr(120); # x
  $rc .= chr(129); # \\201
  $rc .= chr(121); # y
  $rc .= chr(152); # \\230
  $rc .= chr(122); # z
  $rc .= chr(153); # \\231
  $rc .= chr(126); # ~
  $rc .= chr(149); # \\225

  return $rc;
}
',
          '\\233201z' => '
#
# Stub version of: \\233201z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[L' => '
#
# Stub version of: \\E[L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\E1$<15>' => '
#
# Stub version of: \\E1$<15>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[18;6~' => '
#
# Stub version of: \\E[18;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^Y' => '
#
# Stub version of: ^Y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Y

  return $rc;
}
',
          '^B' => '
#
# Stub version of: ^B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B

  return $rc;
}
',
          '\\E[019q' => '
#
# Stub version of: \\E[019q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\EO[' => '
#
# Stub version of: \\EO[
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(91); # [

  return $rc;
}
',
          '\\E[8;0|\\E[?4;5;13;15l\\E[13;20l\\E[?3;7h\\E[12h' => '
#
# Stub version of: \\E[8;0|\\E[?4;5;13;15l\\E[13;20l\\E[?3;7h\\E[12h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[0;7m' => '
#
# Stub version of: \\E[0;7m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[>1;7A' => '
#
# Stub version of: \\E[>1;7A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[G' => '
#
# Stub version of: \\E[G
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\E\\023\\E7' => '
#
# Stub version of: \\E\\023\\E7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7

  return $rc;
}
',
          '^^<' => '
#
# Stub version of: ^^<
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(60); # <

  return $rc;
}
',
          '\\E[%p1%d;0;0;0q%p2%:-16.16s\\E~' => '
#
# Stub version of: \\E[%p1%d;0;0;0q%p2%:-16.16s\\E~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(113); # q
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%-16.16s\', pop(@iparam)); # %-16.16s
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^V^C' => '
#
# Stub version of: ^V^C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^C

  return $rc;
}
',
          '\\E~_b' => '
#
# Stub version of: \\E~_b
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(95); # _
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E[235z' => '
#
# Stub version of: \\E[235z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[?5l\\E[?5h' => '
#
# Stub version of: \\E[?5l\\E[?5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\017%p2%{10}%/%{16}%*%p2%{10}%m%+%c%p1%?%p1%{19}%>%t%{12}%+%;%{64}%+%c' => '
#
# Stub version of: \\017%p2%{10}%/%{16}%*%p2%{10}%m%+%c%p1%?%p1%{19}%>%t%{12}%+%;%{64}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  push(@iparam, $param[1]); # %p2
  push(@iparam, 10); # %{10}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 16); # %{16}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, $param[1]); # %p2
  push(@iparam, 10); # %{10}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 19); # %{19}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, 12); # %{12}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  push(@iparam, 64); # %{64}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[?E' => '
#
# Stub version of: \\E[?E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\E[J$<50/>' => '
#
# Stub version of: \\E[J$<50/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\017\\025\\035\\036E\\036FS00' => '
#
# Stub version of: \\017\\025\\035\\036E\\036FS00
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(21); # \\025
  $rc .= chr(29); # \\035
  $rc .= chr(30); # \\036
  $rc .= chr(69); # E
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '^K^P' => '
#
# Stub version of: ^K^P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^K
  $rc .= chr(0); # ^P

  return $rc;
}
',
          '\\Ea^A' => '
#
# Stub version of: \\Ea^A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(97); # a
  $rc .= chr(0); # ^A

  return $rc;
}
',
          '\\E[&p\\E[<12l\\E F\\E[3g\\E[9;17;25;33;41;49;57;65;73 N' => '
#
# Stub version of: \\E[&p\\E[<12l\\E F\\E[3g\\E[9;17;25;33;41;49;57;65;73 N
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(38); # &
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(32); #  
  $rc .= chr(78); # N

  return $rc;
}
',
          '\\006%p1%d.%p2%d.' => '
#
# Stub version of: \\006%p1%d.%p2%d.
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(6); # \\006
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(46); # .
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(46); # .

  return $rc;
}
',
          '\\E[%p1%dP$<1*>' => '
#
# Stub version of: \\E[%p1%dP$<1*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&f0a%p1%dk%p2%l%Pa%?%ga%t%ga%d%e1%;d0L%?%ga%!%t %;%p2%s' => '
#
# Stub version of: \\E&f0a%p1%dk%p2%l%Pa%?%ga%t%ga%d%e1%;d0L%?%ga%!%t %;%p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(102); # f
  $rc .= chr(48); # 0
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(107); # k
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $dynamicp->[0] = pop(@iparam); # %Pa
  if (do { # %?
           push(@iparam, $dynamicp->[0]); # %ga
           pop(@iparam);
         }) { # %t
    push(@iparam, $dynamicp->[0]); # %ga
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  }
  else { # %e
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(100); # d
  $rc .= chr(48); # 0
  $rc .= chr(76); # L
  if (do { # %?
           push(@iparam, $dynamicp->[0]); # %ga
           push(@iparam, ! pop(@iparam)); # %!
           pop(@iparam);
         }) { # %t
    $rc .= chr(32); #  
  } # %;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\E[0%?%p1%p5%|%p6%|%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%p6%|%t;7%;%?%p7%t;8%;m%?%p8%t\\EV%;%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p1%p5%|%p6%|%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%p6%|%t;7%;%?%p7%t;8%;m%?%p8%t\\EV%;%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[0]); # %p1
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[7]); # %p8
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(86); # V
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '^V"' => '
#
# Stub version of: ^V"
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(34); # "

  return $rc;
}
',
          '\\E[1m$<30>' => '
#
# Stub version of: \\E[1m$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[ A' => '
#
# Stub version of: \\E[ A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(32); #  
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\EFj' => '
#
# Stub version of: \\EFj
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(106); # j

  return $rc;
}
',
          '\\020$<62>' => '
#
# Stub version of: \\020$<62>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[036q' => '
#
# Stub version of: \\E[036q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[44~' => '
#
# Stub version of: \\E[44~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\014$<132>' => '
#
# Stub version of: \\014$<132>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EY%p2%{32}%+%c%p1%{32}%+%c' => '
#
# Stub version of: \\EY%p2%{32}%+%c%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\233309z' => '
#
# Stub version of: \\233309z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[1;43m' => '
#
# Stub version of: \\E[1;43m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(51); # 3
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[22s' => '
#
# Stub version of: \\E[22s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\EEF' => '
#
# Stub version of: \\EEF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\r        \\E9' => '
#
# Stub version of: \\r        \\E9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\ENL' => '
#
# Stub version of: \\ENL
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\E\\003\\E3' => '
#
# Stub version of: \\E\\003\\E3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3

  return $rc;
}
',
          '^B3\\r' => '
#
# Stub version of: ^B3\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(51); # 3
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[L$<99>' => '
#
# Stub version of: \\E[L$<99>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\001$<5>' => '
#
# Stub version of: \\001$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(1); # \\001
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[24p' => '
#
# Stub version of: \\E[24p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\037lea p4 /h/\\r\\037lea p8 /k/\\r\\037lea p6 / /\\r\\037lea p2 /j/\\r\\037lea f5 /H/\\r' => '
#
# Stub version of: \\037lea p4 /h/\\r\\037lea p8 /k/\\r\\037lea p6 / /\\r\\037lea p2 /j/\\r\\037lea f5 /H/\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(97); # a
  $rc .= chr(32); #  
  $rc .= chr(112); # p
  $rc .= chr(52); # 4
  $rc .= chr(32); #  
  $rc .= chr(47); # /
  $rc .= chr(104); # h
  $rc .= chr(47); # /
  $rc .= chr(13); # \\r
  $rc .= chr(31); # \\037
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(97); # a
  $rc .= chr(32); #  
  $rc .= chr(112); # p
  $rc .= chr(56); # 8
  $rc .= chr(32); #  
  $rc .= chr(47); # /
  $rc .= chr(107); # k
  $rc .= chr(47); # /
  $rc .= chr(13); # \\r
  $rc .= chr(31); # \\037
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(97); # a
  $rc .= chr(32); #  
  $rc .= chr(112); # p
  $rc .= chr(54); # 6
  $rc .= chr(32); #  
  $rc .= chr(47); # /
  $rc .= chr(32); #  
  $rc .= chr(47); # /
  $rc .= chr(13); # \\r
  $rc .= chr(31); # \\037
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(97); # a
  $rc .= chr(32); #  
  $rc .= chr(112); # p
  $rc .= chr(50); # 2
  $rc .= chr(32); #  
  $rc .= chr(47); # /
  $rc .= chr(106); # j
  $rc .= chr(47); # /
  $rc .= chr(13); # \\r
  $rc .= chr(31); # \\037
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(97); # a
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(53); # 5
  $rc .= chr(32); #  
  $rc .= chr(47); # /
  $rc .= chr(72); # H
  $rc .= chr(47); # /
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E\\014\\E\\016\\0\\230\\0\\317\\025\\027\\030\\E\\004' => '
#
# Stub version of: \\E\\014\\E\\016\\0\\230\\0\\317\\025\\027\\030\\E\\004
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(12); # \\014
  $rc .= chr(27); # \\E
  $rc .= chr(14); # \\016
  $rc .= chr(128); # \\0
  $rc .= chr(152); # \\230
  $rc .= chr(128); # \\0
  $rc .= chr(207); # \\317
  $rc .= chr(21); # \\025
  $rc .= chr(23); # \\027
  $rc .= chr(24); # \\030
  $rc .= chr(27); # \\E
  $rc .= chr(4); # \\004

  return $rc;
}
',
          '\\E[11;3|' => '
#
# Stub version of: \\E[11;3|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\E[40l' => '
#
# Stub version of: \\E[40l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EE%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\EE%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E)\\s' => '
#
# Stub version of: \\E)\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\EM$<5.5*>' => '
#
# Stub version of: \\EM$<5.5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ELF hl @' => '
#
# Stub version of: \\ELF hl @
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(70); # F
  $rc .= chr(32); #  
  $rc .= chr(104); # h
  $rc .= chr(108); # l
  $rc .= chr(32); #  
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\036FS00' => '
#
# Stub version of: \\036FS00
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\036N\\036FS11\\036O' => '
#
# Stub version of: \\036N\\036FS11\\036O
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(78); # N
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(30); # \\036
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\E[8;0|\\E[?3;4;13;15l\\E[?5h\\E[13;20l\\E[?7h\\E[12h\\E(B\\E)B' => '
#
# Stub version of: \\E[8;0|\\E[?3;4;13;15l\\E[?5h\\E[13;20l\\E[?7h\\E[12h\\E(B\\E)B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\EO1;5R' => '
#
# Stub version of: \\EO1;5R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[1P$<10>' => '
#
# Stub version of: \\E[1P$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[H\\E[J$<156>\\E[30;0;0;30p' => '
#
# Stub version of: \\E[H\\E[J$<156>\\E[30;0;0;30p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p9%t;11%;m' => '
#
# Stub version of: \\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p9%t;11%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[2J\\E[1;1H$<300>' => '
#
# Stub version of: \\E[2J\\E[1;1H$<300>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\'' => '
#
# Stub version of: \\E\'
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'

  return $rc;
}
',
          '\\Ee6\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`;\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<100>' => '
#
# Stub version of: \\Ee6\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`;\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(59); # ;
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(55); # 7
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0;4;5;7m' => '
#
# Stub version of: \\E[0;4;5;7m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\233307z' => '
#
# Stub version of: \\233307z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[4p' => '
#
# Stub version of: \\E[4p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\233200z' => '
#
# Stub version of: \\233200z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\037%p1%c%p2%c' => '
#
# Stub version of: \\037%p1%c%p2%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '^^P1' => '
#
# Stub version of: ^^P1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E=%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\E=%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\EK$<20>' => '
#
# Stub version of: \\EK$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          'U3 PC-DOS Public Domain NANSI.SYS 9-23-86\\n' => '
#
# Stub version of: U3 PC-DOS Public Domain NANSI.SYS 9-23-86\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(85); # U
  $rc .= chr(51); # 3
  $rc .= chr(32); #  
  $rc .= chr(80); # P
  $rc .= chr(67); # C
  $rc .= chr(45); # -
  $rc .= chr(68); # D
  $rc .= chr(79); # O
  $rc .= chr(83); # S
  $rc .= chr(32); #  
  $rc .= chr(80); # P
  $rc .= chr(117); # u
  $rc .= chr(98); # b
  $rc .= chr(108); # l
  $rc .= chr(105); # i
  $rc .= chr(99); # c
  $rc .= chr(32); #  
  $rc .= chr(68); # D
  $rc .= chr(111); # o
  $rc .= chr(109); # m
  $rc .= chr(97); # a
  $rc .= chr(105); # i
  $rc .= chr(110); # n
  $rc .= chr(32); #  
  $rc .= chr(78); # N
  $rc .= chr(65); # A
  $rc .= chr(78); # N
  $rc .= chr(83); # S
  $rc .= chr(73); # I
  $rc .= chr(46); # .
  $rc .= chr(83); # S
  $rc .= chr(89); # Y
  $rc .= chr(83); # S
  $rc .= chr(32); #  
  $rc .= chr(57); # 9
  $rc .= chr(45); # -
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(45); # -
  $rc .= chr(56); # 8
  $rc .= chr(54); # 6
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\EI%p1%d;' => '
#
# Stub version of: \\EI%p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\ELF7l\\177 @' => '
#
# Stub version of: \\ELF7l\\177 @
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(70); # F
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(127); # \\177
  $rc .= chr(32); #  
  $rc .= chr(64); # @

  return $rc;
}
',
          '^A6\\r' => '
#
# Stub version of: ^A6\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(54); # 6
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\377\\331' => '
#
# Stub version of: \\377\\331
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(217); # \\331

  return $rc;
}
',
          '\\E[33;44m' => '
#
# Stub version of: \\E[33;44m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[OR' => '
#
# Stub version of: \\E[OR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(79); # O
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[%p1%d;%p2%db' => '
#
# Stub version of: \\E[%p1%d;%p2%db
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\EFY' => '
#
# Stub version of: \\EFY
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(89); # Y

  return $rc;
}
',
          '\\EFu' => '
#
# Stub version of: \\EFu
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\E[&p\\E[<12l\\E F' => '
#
# Stub version of: \\E[&p\\E[<12l\\E F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(38); # &
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\Eb!' => '
#
# Stub version of: \\Eb!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\E[28\\^' => '
#
# Stub version of: \\E[28\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\ES\\r' => '
#
# Stub version of: \\ES\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E!^H' => '
#
# Stub version of: \\E!^H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(0); # ^H

  return $rc;
}
',
          '\\E[?67h\\E[64;1"p' => '
#
# Stub version of: \\E[?67h\\E[64;1"p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(34); # "
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\377\\213' => '
#
# Stub version of: \\377\\213
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(139); # \\213

  return $rc;
}
',
          '\\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;m%?%p9%t\\E(0%e\\E(B%;' => '
#
# Stub version of: \\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;m%?%p9%t\\E(0%e\\E(B%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;

  return $rc;
}
',
          '\\377\\206' => '
#
# Stub version of: \\377\\206
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(134); # \\206

  return $rc;
}
',
          '^^~' => '
#
# Stub version of: ^^~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\017$<200/>' => '
#
# Stub version of: \\017$<200/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E/>1l\\E/>9h' => '
#
# Stub version of: \\E/>1l\\E/>9h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(57); # 9
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EF04' => '
#
# Stub version of: \\EF04
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\E[=3;0m' => '
#
# Stub version of: \\E[=3;0m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\037up\\r\\037ili\\r' => '
#
# Stub version of: \\037up\\r\\037ili\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(117); # u
  $rc .= chr(112); # p
  $rc .= chr(13); # \\r
  $rc .= chr(31); # \\037
  $rc .= chr(105); # i
  $rc .= chr(108); # l
  $rc .= chr(105); # i
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E`\\:\\0\\EC\\EDF\\E0\\E\'\\E(\\EA21' => '
#
# Stub version of: \\E`\\:\\0\\EC\\EDF\\E0\\E\'\\E(\\EA21
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1

  return $rc;
}
',
          '++\\,\\,--..00``aaffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz~~' => '
#
# Stub version of: ++\\,\\,--..00``aaffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(43); # +
  $rc .= chr(128); # \\,
  $rc .= chr(128); # \\,
  $rc .= chr(45); # -
  $rc .= chr(45); # -
  $rc .= chr(46); # .
  $rc .= chr(46); # .
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(104); # h
  $rc .= chr(104); # h
  $rc .= chr(105); # i
  $rc .= chr(105); # i
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(121); # y
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EeF$<150>' => '
#
# Stub version of: \\EeF$<150>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(70); # F
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO3P' => '
#
# Stub version of: \\EO3P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(51); # 3
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E%!0\\ELBH=\\E%!1' => '
#
# Stub version of: \\E%!0\\ELBH=\\E%!1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(72); # H
  $rc .= chr(61); # =
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[1;40r\\E[40;1H' => '
#
# Stub version of: \\E[1;40r\\E[40;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '+PAGE' => '
#
# Stub version of: +PAGE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(80); # P
  $rc .= chr(65); # A
  $rc .= chr(71); # G
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\EF12' => '
#
# Stub version of: \\EF12
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2

  return $rc;
}
',
          '^N*' => '
#
# Stub version of: ^N*
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^N
  $rc .= chr(42); # *

  return $rc;
}
',
          '\\EO1;3Q' => '
#
# Stub version of: \\EO1;3Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E7\\E[r\\E[m\\E[?7h\\E[?1;4;6l\\E[4l\\E8\\E>' => '
#
# Stub version of: \\E7\\E[r\\E[m\\E[?7h\\E[?1;4;6l\\E[4l\\E8\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EP101;%p1%d.y%p2%s\\E\\\\' => '
#
# Stub version of: \\EP101;%p1%d.y%p2%s\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(46); # .
  $rc .= chr(121); # y
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\Ej\\s' => '
#
# Stub version of: \\Ej\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E=%p1%{32}%+%c%p2%{32}%+%c$<2>' => '
#
# Stub version of: \\E=%p1%{32}%+%c%p2%{32}%+%c$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[11\\^' => '
#
# Stub version of: \\E[11\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\217M' => '
#
# Stub version of: \\217M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\E[?2h\\E[?3l\\E[?5l\\E[?7h\\E[?8h\\E>\\E[?1l\\E F\\E[?42l\\E[?4l' => '
#
# Stub version of: \\E[?2h\\E[?3l\\E[?5l\\E[?7h\\E[?8h\\E>\\E[?1l\\E F\\E[?42l\\E[?4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[b' => '
#
# Stub version of: \\E[b
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E\\:1}\\Ec\\E[?4l\\E[12h' => '
#
# Stub version of: \\E\\:1}\\Ec\\E[?4l\\E[12h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\:
  $rc .= chr(49); # 1
  $rc .= chr(125); # }
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EGt' => '
#
# Stub version of: \\EGt
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\E[5;6~' => '
#
# Stub version of: \\E[5;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[?25h\\E[?12l' => '
#
# Stub version of: \\E[?25h\\E[?12l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(108); # l

  return $rc;
}
',
          '^PI' => '
#
# Stub version of: ^PI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\EG<' => '
#
# Stub version of: \\EG<
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(60); # <

  return $rc;
}
',
          '\\E[4;50m' => '
#
# Stub version of: \\E[4;50m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[$}' => '
#
# Stub version of: \\E[$}
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(36); # $
  $rc .= chr(125); # }

  return $rc;
}
',
          '0_`RjHkGlFmEnIoPqKsQtMuLvOwNxJ' => '
#
# Stub version of: 0_`RjHkGlFmEnIoPqKsQtMuLvOwNxJ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(48); # 0
  $rc .= chr(95); # _
  $rc .= chr(96); # `
  $rc .= chr(82); # R
  $rc .= chr(106); # j
  $rc .= chr(72); # H
  $rc .= chr(107); # k
  $rc .= chr(71); # G
  $rc .= chr(108); # l
  $rc .= chr(70); # F
  $rc .= chr(109); # m
  $rc .= chr(69); # E
  $rc .= chr(110); # n
  $rc .= chr(73); # I
  $rc .= chr(111); # o
  $rc .= chr(80); # P
  $rc .= chr(113); # q
  $rc .= chr(75); # K
  $rc .= chr(115); # s
  $rc .= chr(81); # Q
  $rc .= chr(116); # t
  $rc .= chr(77); # M
  $rc .= chr(117); # u
  $rc .= chr(76); # L
  $rc .= chr(118); # v
  $rc .= chr(79); # O
  $rc .= chr(119); # w
  $rc .= chr(78); # N
  $rc .= chr(120); # x
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\Ez' => '
#
# Stub version of: \\Ez
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z

  return $rc;
}
',
          '^Oi' => '
#
# Stub version of: ^Oi
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^O
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\017%p1%p1%{16}%m%{2}%*%-%{57}%+%c%p2%p2%{16}%m%{2}%*%-%{57}%+%c' => '
#
# Stub version of: \\017%p1%p1%{16}%m%{2}%*%-%{57}%+%c%p2%p2%{16}%m%{2}%*%-%{57}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  push(@iparam, $param[0]); # %p1
  push(@iparam, $param[0]); # %p1
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, 2); # %{2}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  push(@iparam, 57); # %{57}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, $param[1]); # %p2
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, 2); # %{2}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  push(@iparam, 57); # %{57}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\EO\\Eq\\EG\\Ev\\EJ\\EY7 K5 MS Kermit 2.27 +automatic margins 3-17-85\\n' => '
#
# Stub version of: \\EO\\Eq\\EG\\Ev\\EJ\\EY7 K5 MS Kermit 2.27 +automatic margins 3-17-85\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(75); # K
  $rc .= chr(53); # 5
  $rc .= chr(32); #  
  $rc .= chr(77); # M
  $rc .= chr(83); # S
  $rc .= chr(32); #  
  $rc .= chr(75); # K
  $rc .= chr(101); # e
  $rc .= chr(114); # r
  $rc .= chr(109); # m
  $rc .= chr(105); # i
  $rc .= chr(116); # t
  $rc .= chr(32); #  
  $rc .= chr(50); # 2
  $rc .= chr(46); # .
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(43); # +
  $rc .= chr(97); # a
  $rc .= chr(117); # u
  $rc .= chr(116); # t
  $rc .= chr(111); # o
  $rc .= chr(109); # m
  $rc .= chr(97); # a
  $rc .= chr(116); # t
  $rc .= chr(105); # i
  $rc .= chr(99); # c
  $rc .= chr(32); #  
  $rc .= chr(109); # m
  $rc .= chr(97); # a
  $rc .= chr(114); # r
  $rc .= chr(103); # g
  $rc .= chr(105); # i
  $rc .= chr(110); # n
  $rc .= chr(115); # s
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(45); # -
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(45); # -
  $rc .= chr(56); # 8
  $rc .= chr(53); # 5
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '~\\032$<6>' => '
#
# Stub version of: ~\\032$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(26); # \\032
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '^C\\s' => '
#
# Stub version of: ^C\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^C
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '!com 31\\r\\n\\037sto 9 17 25 33 41 49 57 65 73\\r' => '
#
# Stub version of: !com 31\\r\\n\\037sto 9 17 25 33 41 49 57 65 73\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(33); # !
  $rc .= chr(99); # c
  $rc .= chr(111); # o
  $rc .= chr(109); # m
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(31); # \\037
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(111); # o
  $rc .= chr(32); #  
  $rc .= chr(57); # 9
  $rc .= chr(32); #  
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(32); #  
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(32); #  
  $rc .= chr(53); # 5
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(32); #  
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\016$<20>' => '
#
# Stub version of: \\016$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\001\\E3' => '
#
# Stub version of: \\E\\001\\E3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[62;1"p\\E[?5W' => '
#
# Stub version of: \\E[62;1"p\\E[?5W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\E[35m' => '
#
# Stub version of: \\E[35m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\233%i%p1%dG' => '
#
# Stub version of: \\233%i%p1%dG
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\E[^H' => '
#
# Stub version of: \\E[^H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(0); # ^H

  return $rc;
}
',
          '\\EIC' => '
#
# Stub version of: \\EIC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\ERD' => '
#
# Stub version of: \\ERD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(68); # D

  return $rc;
}
',
          '$<6*>' => '
#
# Stub version of: $<6*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\0G' => '
#
# Stub version of: \\0G
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\Ei1' => '
#
# Stub version of: \\Ei1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(105); # i
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[M$<3/>' => '
#
# Stub version of: \\E[M$<3/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '^K' => '
#
# Stub version of: ^K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^K

  return $rc;
}
',
          '\\E[?7h\\E[r\\E[J' => '
#
# Stub version of: \\E[?7h\\E[r\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[H\\E[J$<50>' => '
#
# Stub version of: \\E[H\\E[J$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\337' => '
#
# Stub version of: \\377\\337
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(223); # \\337

  return $rc;
}
',
          '\\E[>1;2C' => '
#
# Stub version of: \\E[>1;2C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E?w' => '
#
# Stub version of: \\E?w
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\EU\\r' => '
#
# Stub version of: \\EU\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^^PC' => '
#
# Stub version of: ^^PC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E>\\E[?3h\\E[?4l\\E[?5l\\E[?7l\\E[?8h\\E[1;42r\\E[42;1H' => '
#
# Stub version of: \\E>\\E[?3h\\E[?4l\\E[?5l\\E[?7l\\E[?8h\\E[1;42r\\E[42;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '$<5.5*>' => '
#
# Stub version of: $<5.5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EFq' => '
#
# Stub version of: \\EFq
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[17~' => '
#
# Stub version of: \\E[17~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[6@' => '
#
# Stub version of: \\E[6@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[C$<1>' => '
#
# Stub version of: \\E[C$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '^K^X\\r' => '
#
# Stub version of: ^K^X\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^K
  $rc .= chr(0); # ^X
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[8\\^' => '
#
# Stub version of: \\E[8\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\E[H\\E[J$<156>\\E[26;0;0;26p' => '
#
# Stub version of: \\E[H\\E[J$<156>\\E[26;0;0;26p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E\\021%p2%c%p1%c$<40>' => '
#
# Stub version of: \\E\\021%p2%c%p1%c$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(17); # \\021
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          'j5k3l2m1n8q\\:t4u9v=w0x6' => '
#
# Stub version of: j5k3l2m1n8q\\:t4u9v=w0x6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(106); # j
  $rc .= chr(53); # 5
  $rc .= chr(107); # k
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(50); # 2
  $rc .= chr(109); # m
  $rc .= chr(49); # 1
  $rc .= chr(110); # n
  $rc .= chr(56); # 8
  $rc .= chr(113); # q
  $rc .= chr(128); # \\:
  $rc .= chr(116); # t
  $rc .= chr(52); # 4
  $rc .= chr(117); # u
  $rc .= chr(57); # 9
  $rc .= chr(118); # v
  $rc .= chr(61); # =
  $rc .= chr(119); # w
  $rc .= chr(48); # 0
  $rc .= chr(120); # x
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\233?25l' => '
#
# Stub version of: \\233?25l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\0q' => '
#
# Stub version of: \\0q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[%p1%d;%p2%l%02dq   F%p1%d           %p2%s' => '
#
# Stub version of: \\E[%p1%d;%p2%l%02dq   F%p1%d           %p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%02d\', pop(@iparam)); # %02d
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '^Or' => '
#
# Stub version of: ^Or
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^O
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[1;7m' => '
#
# Stub version of: \\E[1;7m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EOT' => '
#
# Stub version of: \\EOT
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\EI$<5>' => '
#
# Stub version of: \\EI$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\037rig;' => '
#
# Stub version of: \\037rig;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(114); # r
  $rc .= chr(105); # i
  $rc .= chr(103); # g
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E(%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\E(%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\010$<4>' => '
#
# Stub version of: \\010$<4>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(8); # \\010
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[2v' => '
#
# Stub version of: \\E[2v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\E[=3l\\EF1\\Ed\\EG0\\E[=5h\\E%\\El' => '
#
# Stub version of: \\E[=3l\\EF1\\Ed\\EG0\\E[=5h\\E%\\El
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[31~' => '
#
# Stub version of: \\E[31~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EM!' => '
#
# Stub version of: \\EM!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\377\\312' => '
#
# Stub version of: \\377\\312
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(202); # \\312

  return $rc;
}
',
          '\\E\\034Eg\\El' => '
#
# Stub version of: \\E\\034Eg\\El
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(28); # \\034
  $rc .= chr(69); # E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[30;1m' => '
#
# Stub version of: \\E[30;1m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[?1002%?%p1%{1}%=%th%el%;' => '
#
# Stub version of: \\E[?1002%?%p1%{1}%=%th%el%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(104); # h
  }
  else { # %e
    $rc .= chr(108); # l
  } # %;

  return $rc;
}
',
          '\\E>\\E[?1l\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[1;24r' => '
#
# Stub version of: \\E>\\E[?1l\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[1;24r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r

  return $rc;
}
',
          'jdkclfmenbqattuvvuwsx`' => '
#
# Stub version of: jdkclfmenbqattuvvuwsx`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(106); # j
  $rc .= chr(100); # d
  $rc .= chr(107); # k
  $rc .= chr(99); # c
  $rc .= chr(108); # l
  $rc .= chr(102); # f
  $rc .= chr(109); # m
  $rc .= chr(101); # e
  $rc .= chr(110); # n
  $rc .= chr(98); # b
  $rc .= chr(113); # q
  $rc .= chr(97); # a
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(117); # u
  $rc .= chr(119); # w
  $rc .= chr(115); # s
  $rc .= chr(120); # x
  $rc .= chr(96); # `

  return $rc;
}
',
          '\\Eu\\E3' => '
#
# Stub version of: \\Eu\\E3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[0;8m' => '
#
# Stub version of: \\E[0;8m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EM(' => '
#
# Stub version of: \\EM(
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(40); # (

  return $rc;
}
',
          'F9' => '
#
# Stub version of: F9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\EOP' => '
#
# Stub version of: \\EOP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\Ej\\EYA%+ \\Eo' => '
#
# Stub version of: \\Ej\\EYA%+ \\Eo
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(65); # A
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\0A' => '
#
# Stub version of: \\0A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[%p1%d;%p2%l%02d;0;1q   F%p1%d           %p2%s' => '
#
# Stub version of: \\E[%p1%d;%p2%l%02d;0;1q   F%p1%d           %p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%02d\', pop(@iparam)); # %02d
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\020%p1%c\\177' => '
#
# Stub version of: \\020%p1%c\\177
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(127); # \\177

  return $rc;
}
',
          '\\233009z' => '
#
# Stub version of: \\233009z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E_' => '
#
# Stub version of: \\E_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _

  return $rc;
}
',
          '\\E[m\\E(B\\017' => '
#
# Stub version of: \\E[m\\E(B\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\ENE' => '
#
# Stub version of: \\ENE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\EK\\E!\\E F' => '
#
# Stub version of: \\EK\\E!\\E F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\EO5F' => '
#
# Stub version of: \\EO5F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(53); # 5
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E7\\E[60;0;0;48p\\E8' => '
#
# Stub version of: \\E7\\E[60;0;0;48p\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '^^`' => '
#
# Stub version of: ^^`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(96); # `

  return $rc;
}
',
          '\\Ej\\EY8%+ \\Eo' => '
#
# Stub version of: \\Ej\\EY8%+ \\Eo
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(56); # 8
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\EOf' => '
#
# Stub version of: \\EOf
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\E[%?%p1%t7;%;%?%p2%t4;%;%?%p3%t7;%;%?%p4%t5;%;%?%p6%t1;%;%?%p7%t8;%;%?%p8%t99;%;m%?%p5%t\\E[1!{%;%?%p9%t\\017%e\\016%;$<1>' => '
#
# Stub version of: \\E[%?%p1%t7;%;%?%p2%t4;%;%?%p3%t7;%;%?%p4%t5;%;%?%p6%t1;%;%?%p7%t8;%;%?%p8%t99;%;m%?%p5%t\\E[1!{%;%?%p9%t\\017%e\\016%;$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(56); # 8
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[7]); # %p8
           pop(@iparam);
         }) { # %t
    $rc .= chr(57); # 9
    $rc .= chr(57); # 9
    $rc .= chr(59); # ;
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(49); # 1
    $rc .= chr(33); # !
    $rc .= chr(123); # {
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(15); # \\017
  }
  else { # %e
    $rc .= chr(14); # \\016
  } # %;
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '~^_' => '
#
# Stub version of: ~^_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(0); # ^_

  return $rc;
}
',
          '\\E[1;2R' => '
#
# Stub version of: \\E[1;2R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[7m$<2>' => '
#
# Stub version of: \\E[7m$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^\\,' => '
#
# Stub version of: ^^\\,
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(128); # \\,

  return $rc;
}
',
          '\\0>' => '
#
# Stub version of: \\0>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E(B\\E)1\\E[5;0|' => '
#
# Stub version of: \\E(B\\E)1\\E[5;0|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\E[2$~\\E[1$}' => '
#
# Stub version of: \\E[2$~\\E[1$}
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(126); # ~
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(125); # }

  return $rc;
}
',
          '\\E[1$}\\E[2$~\\n\\E[0$}' => '
#
# Stub version of: \\E[1$}\\E[2$~\\n\\E[0$}
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(125); # }
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(126); # ~
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(125); # }

  return $rc;
}
',
          '\\EF\\Ef3;' => '
#
# Stub version of: \\EF\\Ef3;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[<0;<1;<4l\\E[m' => '
#
# Stub version of: \\E[<0;<1;<4l\\E[m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[1;2P' => '
#
# Stub version of: \\E[1;2P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(80); # P

  return $rc;
}
',
          '^R^N' => '
#
# Stub version of: ^R^N
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^R
  $rc .= chr(0); # ^N

  return $rc;
}
',
          '\\E[?47h' => '
#
# Stub version of: \\E[?47h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E&d%?%p7%t%{115}%c%;%p1%p3%|%p6%|%{2}%*%p2%{4}%*%+%p4%+%p5%{8}%*%+%{64}%+%c%?%p9%t%\'\\016\'%c%e%\'\\017\'%c%;' => '
#
# Stub version of: \\E&d%?%p7%t%{115}%c%;%p1%p3%|%p6%|%{2}%*%p2%{4}%*%+%p4%+%p5%{8}%*%+%{64}%+%c%?%p9%t%\'\\016\'%c%e%\'\\017\'%c%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    push(@iparam, 115); # %{115}
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  } # %;
  push(@iparam, $param[0]); # %p1
  push(@iparam, $param[2]); # %p3
  push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  push(@iparam, $param[5]); # %p6
  push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  push(@iparam, 2); # %{2}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, $param[1]); # %p2
  push(@iparam, 4); # %{4}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, $param[3]); # %p4
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, $param[4]); # %p5
  push(@iparam, 8); # %{8}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, 64); # %{64}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    push(@iparam, chr(14)); # %\'\\016\'
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  }
  else { # %e
    push(@iparam, chr(15)); # %\'\\017\'
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  } # %;

  return $rc;
}
',
          '\\E0`\\E)' => '
#
# Stub version of: \\E0`\\E)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(96); # `
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )

  return $rc;
}
',
          '\\E8m' => '
#
# Stub version of: \\E8m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EL$<2.1/>' => '
#
# Stub version of: \\EL$<2.1/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(46); # .
  $rc .= chr(49); # 1
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E?7h' => '
#
# Stub version of: \\E?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\23340~' => '
#
# Stub version of: \\23340~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^A>1' => '
#
# Stub version of: ^A>1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(62); # >
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\377\\367' => '
#
# Stub version of: \\377\\367
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(247); # \\367

  return $rc;
}
',
          '^^5' => '
#
# Stub version of: ^^5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\016\\024\\E\'\\E(' => '
#
# Stub version of: \\016\\024\\E\'\\E(
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  $rc .= chr(20); # \\024
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (

  return $rc;
}
',
          '\\E[13l\\E[3l\\E!p\\E[?4i' => '
#
# Stub version of: \\E[13l\\E[3l\\E!p\\E[?4i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\EO6Q' => '
#
# Stub version of: \\EO6Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(54); # 6
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\ENi' => '
#
# Stub version of: \\ENi
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(105); # i

  return $rc;
}
',
          '+\\020\\,\\021-\\030.^Y0\\333`\\004a\\261f\\370g\\361h\\260j\\331k\\277l\\332m\\300n\\305o~p\\304q\\304r\\304s_t\\303u\\264v\\301w\\302x\\263y\\363z\\362{\\343|\\330}\\234~\\376' => '
#
# Stub version of: +\\020\\,\\021-\\030.^Y0\\333`\\004a\\261f\\370g\\361h\\260j\\331k\\277l\\332m\\300n\\305o~p\\304q\\304r\\304s_t\\303u\\264v\\301w\\302x\\263y\\363z\\362{\\343|\\330}\\234~\\376
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(16); # \\020
  $rc .= chr(128); # \\,
  $rc .= chr(17); # \\021
  $rc .= chr(45); # -
  $rc .= chr(24); # \\030
  $rc .= chr(46); # .
  $rc .= chr(0); # ^Y
  $rc .= chr(48); # 0
  $rc .= chr(219); # \\333
  $rc .= chr(96); # `
  $rc .= chr(4); # \\004
  $rc .= chr(97); # a
  $rc .= chr(177); # \\261
  $rc .= chr(102); # f
  $rc .= chr(248); # \\370
  $rc .= chr(103); # g
  $rc .= chr(241); # \\361
  $rc .= chr(104); # h
  $rc .= chr(176); # \\260
  $rc .= chr(106); # j
  $rc .= chr(217); # \\331
  $rc .= chr(107); # k
  $rc .= chr(191); # \\277
  $rc .= chr(108); # l
  $rc .= chr(218); # \\332
  $rc .= chr(109); # m
  $rc .= chr(192); # \\300
  $rc .= chr(110); # n
  $rc .= chr(197); # \\305
  $rc .= chr(111); # o
  $rc .= chr(126); # ~
  $rc .= chr(112); # p
  $rc .= chr(196); # \\304
  $rc .= chr(113); # q
  $rc .= chr(196); # \\304
  $rc .= chr(114); # r
  $rc .= chr(196); # \\304
  $rc .= chr(115); # s
  $rc .= chr(95); # _
  $rc .= chr(116); # t
  $rc .= chr(195); # \\303
  $rc .= chr(117); # u
  $rc .= chr(180); # \\264
  $rc .= chr(118); # v
  $rc .= chr(193); # \\301
  $rc .= chr(119); # w
  $rc .= chr(194); # \\302
  $rc .= chr(120); # x
  $rc .= chr(179); # \\263
  $rc .= chr(121); # y
  $rc .= chr(243); # \\363
  $rc .= chr(122); # z
  $rc .= chr(242); # \\362
  $rc .= chr(123); # {
  $rc .= chr(227); # \\343
  $rc .= chr(124); # |
  $rc .= chr(216); # \\330
  $rc .= chr(125); # }
  $rc .= chr(156); # \\234
  $rc .= chr(126); # ~
  $rc .= chr(254); # \\376

  return $rc;
}
',
          '\\E[?1l\\E[?7h\\E=' => '
#
# Stub version of: \\E[?1l\\E[?7h\\E=
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =

  return $rc;
}
',
          '\\020\\010\\030\\035$<10*>' => '
#
# Stub version of: \\020\\010\\030\\035$<10*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  $rc .= chr(8); # \\010
  $rc .= chr(24); # \\030
  $rc .= chr(29); # \\035
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E!\\s' => '
#
# Stub version of: \\E!\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\217D' => '
#
# Stub version of: \\217D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\EO1;2P' => '
#
# Stub version of: \\EO1;2P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\EDF\\EC\\Eb\\EG0\\Eg\\Er\\EO\\E\'\\E(\\E%\\Ew\\EX\\Ee \\017\\011\\Ek\\E016\\E004\\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\011\\Ex3\\0\\0\\Ex4\\r\\0\\E\\\\2\\E-07\\s' => '
#
# Stub version of: \\EDF\\EC\\Eb\\EG0\\Eg\\Er\\EO\\E\'\\E(\\E%\\Ew\\EX\\Ee \\017\\011\\Ek\\E016\\E004\\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\011\\Ex3\\0\\0\\Ex4\\r\\0\\E\\\\2\\E-07\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(32); #  
  $rc .= chr(15); # \\017
  $rc .= chr(9); # \\011
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(9); # \\011
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(52); # 4
  $rc .= chr(13); # \\r
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(45); # -
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E[K$<1>' => '
#
# Stub version of: \\E[K$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '^\\Z' => '
#
# Stub version of: ^\\Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(92); # \\
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\E0I' => '
#
# Stub version of: \\E0I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\2330m' => '
#
# Stub version of: \\2330m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[>1;6D' => '
#
# Stub version of: \\E[>1;6D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\233 A' => '
#
# Stub version of: \\233 A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(32); #  
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\0\\205' => '
#
# Stub version of: \\0\\205
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(133); # \\205

  return $rc;
}
',
          '^B=\\r' => '
#
# Stub version of: ^B=\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(61); # =
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EK' => '
#
# Stub version of: \\EK
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\037lea p2\\r\\037lea p4\\r\\037lea p6\\r\\037lea p8\\r\\037lea f5\\r' => '
#
# Stub version of: \\037lea p2\\r\\037lea p4\\r\\037lea p6\\r\\037lea p8\\r\\037lea f5\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(97); # a
  $rc .= chr(32); #  
  $rc .= chr(112); # p
  $rc .= chr(50); # 2
  $rc .= chr(13); # \\r
  $rc .= chr(31); # \\037
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(97); # a
  $rc .= chr(32); #  
  $rc .= chr(112); # p
  $rc .= chr(52); # 4
  $rc .= chr(13); # \\r
  $rc .= chr(31); # \\037
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(97); # a
  $rc .= chr(32); #  
  $rc .= chr(112); # p
  $rc .= chr(54); # 6
  $rc .= chr(13); # \\r
  $rc .= chr(31); # \\037
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(97); # a
  $rc .= chr(32); #  
  $rc .= chr(112); # p
  $rc .= chr(56); # 8
  $rc .= chr(13); # \\r
  $rc .= chr(31); # \\037
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(97); # a
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(53); # 5
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[0m\\E[1;33;44m' => '
#
# Stub version of: \\E[0m\\E[1;33;44m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Ey2' => '
#
# Stub version of: \\Ey2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E_G\\E\\\\' => '
#
# Stub version of: \\E_G\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\EO4C' => '
#
# Stub version of: \\EO4C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(52); # 4
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\233%p1%dX' => '
#
# Stub version of: \\233%p1%dX
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(88); # X

  return $rc;
}
',
          '\\EV$<49.6/>' => '
#
# Stub version of: \\EV$<49.6/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(46); # .
  $rc .= chr(54); # 6
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '$<1>\\r' => '
#
# Stub version of: $<1>\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Ew0$<20>' => '
#
# Stub version of: \\Ew0$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^N' => '
#
# Stub version of: ^^N
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(78); # N

  return $rc;
}
',
          '\\377\\370' => '
#
# Stub version of: \\377\\370
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(248); # \\370

  return $rc;
}
',
          '\\EsP' => '
#
# Stub version of: \\EsP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\EO1;6R' => '
#
# Stub version of: \\EO1;6R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\Eo' => '
#
# Stub version of: \\Eo
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\E[21;1j\\E[25;4j\\Eent' => '
#
# Stub version of: \\E[21;1j\\E[25;4j\\Eent
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(110); # n
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\EO3B' => '
#
# Stub version of: \\EO3B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(51); # 3
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[%p1%dP$<40>' => '
#
# Stub version of: \\E[%p1%dP$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          'DEL CH' => '
#
# Stub version of: DEL CH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(68); # D
  $rc .= chr(69); # E
  $rc .= chr(76); # L
  $rc .= chr(32); #  
  $rc .= chr(67); # C
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[99H' => '
#
# Stub version of: \\E[99H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[147q' => '
#
# Stub version of: \\E[147q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E!^A' => '
#
# Stub version of: \\E!^A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(0); # ^A

  return $rc;
}
',
          '\\EIL' => '
#
# Stub version of: \\EIL
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\E7\\E[r\\E8\\EE\\EE\\EE\\EM\\EM\\EM\\E[?7h\\E[?1l\\E[?3l\\E7\\E[1;28r\\E8' => '
#
# Stub version of: \\E7\\E[r\\E8\\EE\\EE\\EE\\EM\\EM\\EM\\E[?7h\\E[?1l\\E[?3l\\E7\\E[1;28r\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E F\\E"' => '
#
# Stub version of: \\E F\\E"
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "

  return $rc;
}
',
          '\\Ew\\E\'\\EDF\\El\\Er\\EO' => '
#
# Stub version of: \\Ew\\E\'\\EDF\\El\\Er\\EO
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\E[J$<30>' => '
#
# Stub version of: \\E[J$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E0`\\016' => '
#
# Stub version of: \\E0`\\016
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(96); # `
  $rc .= chr(14); # \\016

  return $rc;
}
',
          '\\E|%{48}%p1%+%c2%p2\\031' => '
#
# Stub version of: \\E|%{48}%p1%+%c2%p2\\031
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(124); # |
  push(@iparam, 48); # %{48}
  push(@iparam, $param[0]); # %p1
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(50); # 2
  push(@iparam, $param[1]); # %p2
  $rc .= chr(25); # \\031

  return $rc;
}
',
          '\\E[n' => '
#
# Stub version of: \\E[n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\Eg' => '
#
# Stub version of: \\Eg
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\377\\261' => '
#
# Stub version of: \\377\\261
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(177); # \\261

  return $rc;
}
',
          '\\E[r\\E[m\\E[?7h\\E[?4;6l\\E[4l' => '
#
# Stub version of: \\E[r\\E[m\\E[?7h\\E[?4;6l\\E[4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[`' => '
#
# Stub version of: \\E[`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(96); # `

  return $rc;
}
',
          '\\E=\\E[0q\\E>' => '
#
# Stub version of: \\E=\\E[0q\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EH\\EJ$<50>' => '
#
# Stub version of: \\EH\\EJ$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[30;H' => '
#
# Stub version of: \\E[30;H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[9m' => '
#
# Stub version of: \\E[9m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\377\\313' => '
#
# Stub version of: \\377\\313
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(203); # \\313

  return $rc;
}
',
          '\\E[18s' => '
#
# Stub version of: \\E[18s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E!e\\r' => '
#
# Stub version of: \\E!e\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(101); # e
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '+/\\,.0[a2fxgqh1ihjYk?lZm@nEqDtCu4vAwBx3yszr{c~~' => '
#
# Stub version of: +/\\,.0[a2fxgqh1ihjYk?lZm@nEqDtCu4vAwBx3yszr{c~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(47); # /
  $rc .= chr(128); # \\,
  $rc .= chr(46); # .
  $rc .= chr(48); # 0
  $rc .= chr(91); # [
  $rc .= chr(97); # a
  $rc .= chr(50); # 2
  $rc .= chr(102); # f
  $rc .= chr(120); # x
  $rc .= chr(103); # g
  $rc .= chr(113); # q
  $rc .= chr(104); # h
  $rc .= chr(49); # 1
  $rc .= chr(105); # i
  $rc .= chr(104); # h
  $rc .= chr(106); # j
  $rc .= chr(89); # Y
  $rc .= chr(107); # k
  $rc .= chr(63); # ?
  $rc .= chr(108); # l
  $rc .= chr(90); # Z
  $rc .= chr(109); # m
  $rc .= chr(64); # @
  $rc .= chr(110); # n
  $rc .= chr(69); # E
  $rc .= chr(113); # q
  $rc .= chr(68); # D
  $rc .= chr(116); # t
  $rc .= chr(67); # C
  $rc .= chr(117); # u
  $rc .= chr(52); # 4
  $rc .= chr(118); # v
  $rc .= chr(65); # A
  $rc .= chr(119); # w
  $rc .= chr(66); # B
  $rc .= chr(120); # x
  $rc .= chr(51); # 3
  $rc .= chr(121); # y
  $rc .= chr(115); # s
  $rc .= chr(122); # z
  $rc .= chr(114); # r
  $rc .= chr(123); # {
  $rc .= chr(99); # c
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EF19' => '
#
# Stub version of: \\EF19
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\036D$<5/>' => '
#
# Stub version of: \\036D$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(68); # D
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ee\\EU01^Z1\\EV\\EU02^Z2\\EV\\EU03^Z3\\EV\\EU04^Z4\\EV\\EU05^Z5\\EV\\EU06^Z6\\EV\\EU07^Z7\\EV\\EU08^Z8\\EV\\Ef' => '
#
# Stub version of: \\Ee\\EU01^Z1\\EV\\EU02^Z2\\EV\\EU03^Z3\\EV\\EU04^Z4\\EV\\EU05^Z5\\EV\\EU06^Z6\\EV\\EU07^Z7\\EV\\EU08^Z8\\EV\\Ef
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(0); # ^Z
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(0); # ^Z
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(0); # ^Z
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(0); # ^Z
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(0); # ^Z
  $rc .= chr(53); # 5
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(0); # ^Z
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(0); # ^Z
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(0); # ^Z
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f

  return $rc;
}
',
          'j\\331k\\277l\\332m\\300n\\305q\\304t\\303u\\264v\\301w\\302x\\263' => '
#
# Stub version of: j\\331k\\277l\\332m\\300n\\305q\\304t\\303u\\264v\\301w\\302x\\263
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(106); # j
  $rc .= chr(217); # \\331
  $rc .= chr(107); # k
  $rc .= chr(191); # \\277
  $rc .= chr(108); # l
  $rc .= chr(218); # \\332
  $rc .= chr(109); # m
  $rc .= chr(192); # \\300
  $rc .= chr(110); # n
  $rc .= chr(197); # \\305
  $rc .= chr(113); # q
  $rc .= chr(196); # \\304
  $rc .= chr(116); # t
  $rc .= chr(195); # \\303
  $rc .= chr(117); # u
  $rc .= chr(180); # \\264
  $rc .= chr(118); # v
  $rc .= chr(193); # \\301
  $rc .= chr(119); # w
  $rc .= chr(194); # \\302
  $rc .= chr(120); # x
  $rc .= chr(179); # \\263

  return $rc;
}
',
          '\\E[;H\\E[2J$<20/>' => '
#
# Stub version of: \\E[;H\\E[2J$<20/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\037@A\\024\\n' => '
#
# Stub version of: \\037@A\\024\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(64); # @
  $rc .= chr(65); # A
  $rc .= chr(20); # \\024
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;$<20>' => '
#
# Stub version of: \\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0;10m\\E(B' => '
#
# Stub version of: \\E[0;10m\\E(B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\001W0\\,40\\,85\\,48\\,\\014\\001W0\\,0\\,85\\,48\\,\\001M0\\,40\\,' => '
#
# Stub version of: \\001W0\\,40\\,85\\,48\\,\\014\\001W0\\,0\\,85\\,48\\,\\001M0\\,40\\,
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(1); # \\001
  $rc .= chr(87); # W
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(56); # 8
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\,
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(128); # \\,
  $rc .= chr(12); # \\014
  $rc .= chr(1); # \\001
  $rc .= chr(87); # W
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(56); # 8
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\,
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(128); # \\,
  $rc .= chr(1); # \\001
  $rc .= chr(77); # M
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,

  return $rc;
}
',
          '\\E[6 D' => '
#
# Stub version of: \\E[6 D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(32); #  
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[M$<2>' => '
#
# Stub version of: \\E[M$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p9%t;11%;m' => '
#
# Stub version of: \\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p9%t;11%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\037rig %p1%d\\r' => '
#
# Stub version of: \\037rig %p1%d\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(114); # r
  $rc .= chr(105); # i
  $rc .= chr(103); # g
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '0pjdkblamcnkqitgufvhwexj' => '
#
# Stub version of: 0pjdkblamcnkqitgufvhwexj
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(106); # j
  $rc .= chr(100); # d
  $rc .= chr(107); # k
  $rc .= chr(98); # b
  $rc .= chr(108); # l
  $rc .= chr(97); # a
  $rc .= chr(109); # m
  $rc .= chr(99); # c
  $rc .= chr(110); # n
  $rc .= chr(107); # k
  $rc .= chr(113); # q
  $rc .= chr(105); # i
  $rc .= chr(116); # t
  $rc .= chr(103); # g
  $rc .= chr(117); # u
  $rc .= chr(102); # f
  $rc .= chr(118); # v
  $rc .= chr(104); # h
  $rc .= chr(119); # w
  $rc .= chr(101); # e
  $rc .= chr(120); # x
  $rc .= chr(106); # j

  return $rc;
}
',
          '\\E[192z' => '
#
# Stub version of: \\E[192z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[%p1%dB$<30>' => '
#
# Stub version of: \\E[%p1%dB$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(66); # B
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\036PJ\\025\\035\\036E\\036FS00' => '
#
# Stub version of: \\036PJ\\025\\035\\036E\\036FS00
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(80); # P
  $rc .= chr(74); # J
  $rc .= chr(21); # \\025
  $rc .= chr(29); # \\035
  $rc .= chr(30); # \\036
  $rc .= chr(69); # E
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[%p1%dG$<40>' => '
#
# Stub version of: \\E[%p1%dG$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(71); # G
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E#G' => '
#
# Stub version of: \\E#G
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\036%p1%{32}%+%c%p2%{32}%+%c$<100/>' => '
#
# Stub version of: \\036%p1%{32}%+%c%p2%{32}%+%c$<100/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EF6' => '
#
# Stub version of: \\EF6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E[15;6~' => '
#
# Stub version of: \\E[15;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E2n' => '
#
# Stub version of: \\E2n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\E[146q' => '
#
# Stub version of: \\E[146q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(54); # 6
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E^Z' => '
#
# Stub version of: \\E^Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^Z

  return $rc;
}
',
          '\\E[{' => '
#
# Stub version of: \\E[{
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(123); # {

  return $rc;
}
',
          '\\E$C' => '
#
# Stub version of: \\E$C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\EOB' => '
#
# Stub version of: \\EOB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\0L' => '
#
# Stub version of: \\0L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\EE$<5*>' => '
#
# Stub version of: \\EE$<5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\2334l' => '
#
# Stub version of: \\2334l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '^Aj\\r' => '
#
# Stub version of: ^Aj\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(106); # j
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '07a?h;j5k3l2m1n8q\\:t4u9v=w0x6' => '
#
# Stub version of: 07a?h;j5k3l2m1n8q\\:t4u9v=w0x6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(97); # a
  $rc .= chr(63); # ?
  $rc .= chr(104); # h
  $rc .= chr(59); # ;
  $rc .= chr(106); # j
  $rc .= chr(53); # 5
  $rc .= chr(107); # k
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(50); # 2
  $rc .= chr(109); # m
  $rc .= chr(49); # 1
  $rc .= chr(110); # n
  $rc .= chr(56); # 8
  $rc .= chr(113); # q
  $rc .= chr(128); # \\:
  $rc .= chr(116); # t
  $rc .= chr(52); # 4
  $rc .= chr(117); # u
  $rc .= chr(57); # 9
  $rc .= chr(118); # v
  $rc .= chr(61); # =
  $rc .= chr(119); # w
  $rc .= chr(48); # 0
  $rc .= chr(120); # x
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\016A\\036$<3.5>' => '
#
# Stub version of: \\016A\\036$<3.5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  $rc .= chr(65); # A
  $rc .= chr(30); # \\036
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E]4;%p1%d;rgb\\:%p2%{255}%*%{1000}%/%2.2X/%p3%{255}%*%{1000}%/%2.2X/%p4%{255}%*%{1000}%/%2.2X\\E\\\\' => '
#
# Stub version of: \\E]4;%p1%d;rgb\\:%p2%{255}%*%{1000}%/%2.2X/%p3%{255}%*%{1000}%/%2.2X/%p4%{255}%*%{1000}%/%2.2X\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  $rc .= chr(114); # r
  $rc .= chr(103); # g
  $rc .= chr(98); # b
  $rc .= chr(128); # \\:
  push(@iparam, $param[1]); # %p2
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  $rc .= chr(47); # /
  push(@iparam, $param[2]); # %p3
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  $rc .= chr(47); # /
  push(@iparam, $param[3]); # %p4
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\001C1\\,\\001c2\\,' => '
#
# Stub version of: \\001C1\\,\\001c2\\,
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(1); # \\001
  $rc .= chr(67); # C
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\,
  $rc .= chr(1); # \\001
  $rc .= chr(99); # c
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\,

  return $rc;
}
',
          '\\E[2!w\\r\\n\\E[!w' => '
#
# Stub version of: \\E[2!w\\r\\n\\E[!w
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(33); # !
  $rc .= chr(119); # w
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\E]=' => '
#
# Stub version of: \\E]=
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(61); # =

  return $rc;
}
',
          '\\Enext' => '
#
# Stub version of: \\Enext
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(110); # n
  $rc .= chr(101); # e
  $rc .= chr(120); # x
  $rc .= chr(116); # t

  return $rc;
}
',
          'F15' => '
#
# Stub version of: F15
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\377\\247' => '
#
# Stub version of: \\377\\247
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(167); # \\247

  return $rc;
}
',
          '^M^J' => '
#
# Stub version of: ^M^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^M
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '^M^^' => '
#
# Stub version of: ^M^^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^M
  $rc .= chr(0); # ^^

  return $rc;
}
',
          '\\E[7s\\E[2;3;4;20;?5;?6l\\E[12;?7h\\E[1Q\\E[0;1(D\\E[8s' => '
#
# Stub version of: \\E[7s\\E[2;3;4;20;?5;?6l\\E[12;?7h\\E[1Q\\E[0;1(D\\E[8s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(40); # (
  $rc .= chr(68); # D
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E[8;5~' => '
#
# Stub version of: \\E[8;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[23$' => '
#
# Stub version of: \\E[23$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\E?x' => '
#
# Stub version of: \\E?x
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\E[=4l\\E[1;24w\\E2\\r' => '
#
# Stub version of: \\E[=4l\\E[1;24w\\E2\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E3\\Eb\\Ej\\E\\El\\EG\\Ec\\Ek\\EX' => '
#
# Stub version of: \\E3\\Eb\\Ej\\E\\El\\EG\\Ec\\Ek\\EX
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X

  return $rc;
}
',
          '\\EV!' => '
#
# Stub version of: \\EV!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\E\'1' => '
#
# Stub version of: \\E\'1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[1;4D' => '
#
# Stub version of: \\E[1;4D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[11r' => '
#
# Stub version of: \\E[11r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(114); # r

  return $rc;
}
',
          '^Nl' => '
#
# Stub version of: ^Nl
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^N
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\233210z' => '
#
# Stub version of: \\233210z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[23;3~' => '
#
# Stub version of: \\E[23;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[308z' => '
#
# Stub version of: \\E[308z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EV' => '
#
# Stub version of: \\EV
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(86); # V

  return $rc;
}
',
          '\\E[%p1%dP$<250>' => '
#
# Stub version of: \\E[%p1%dP$<250>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E9h' => '
#
# Stub version of: \\E9h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\217q' => '
#
# Stub version of: \\217q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\233?1049l' => '
#
# Stub version of: \\233?1049l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\377\\307' => '
#
# Stub version of: \\377\\307
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(199); # \\307

  return $rc;
}
',
          '\\n$<1>' => '
#
# Stub version of: \\n$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          'USR_TERM\\:vt420pcdos\\:' => '
#
# Stub version of: USR_TERM\\:vt420pcdos\\:
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(85); # U
  $rc .= chr(83); # S
  $rc .= chr(82); # R
  $rc .= chr(95); # _
  $rc .= chr(84); # T
  $rc .= chr(69); # E
  $rc .= chr(82); # R
  $rc .= chr(77); # M
  $rc .= chr(128); # \\:
  $rc .= chr(118); # v
  $rc .= chr(116); # t
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(99); # c
  $rc .= chr(100); # d
  $rc .= chr(111); # o
  $rc .= chr(115); # s
  $rc .= chr(128); # \\:

  return $rc;
}
',
          '\\E[1;5A' => '
#
# Stub version of: \\E[1;5A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\EFF' => '
#
# Stub version of: \\EFF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E[?13l' => '
#
# Stub version of: \\E[?13l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EwG\\Ee($<200>' => '
#
# Stub version of: \\EwG\\Ee($<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(40); # (
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[53;3|' => '
#
# Stub version of: \\E[53;3|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\E[?19h\\E[0i' => '
#
# Stub version of: \\E[?19h\\E[0i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\EFG' => '
#
# Stub version of: \\EFG
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\377\\300' => '
#
# Stub version of: \\377\\300
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(192); # \\300

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%d;%i%p3%d;%p4%dr' => '
#
# Stub version of: \\E[%i%p1%d;%p2%d;%i%p3%d;%p4%dr
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[2]); # %p3
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[3]); # %p4
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\EQ\\EU\\EV' => '
#
# Stub version of: \\EQ\\EU\\EV
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V

  return $rc;
}
',
          '\\E[0;2;4m' => '
#
# Stub version of: \\E[0;2;4m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\233214z' => '
#
# Stub version of: \\233214z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '^AB\\r' => '
#
# Stub version of: ^AB\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(66); # B
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\2331C' => '
#
# Stub version of: \\2331C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(67); # C

  return $rc;
}
',
          '^B2' => '
#
# Stub version of: ^B2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(50); # 2

  return $rc;
}
',
          '^E^R' => '
#
# Stub version of: ^E^R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^E
  $rc .= chr(0); # ^R

  return $rc;
}
',
          '\\E7\\E[?6l\\E[2K\\E[?6h\\E8' => '
#
# Stub version of: \\E7\\E[?6l\\E[2K\\E[?6h\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E&I$<2*/>' => '
#
# Stub version of: \\E&I$<2*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(73); # I
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EQ$<20*>' => '
#
# Stub version of: \\EQ$<20*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EP\\n\\EQ$<130>' => '
#
# Stub version of: \\EP\\n\\EQ$<130>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[012q' => '
#
# Stub version of: \\E[012q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\r$<1>' => '
#
# Stub version of: \\r$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[H\\E[J$<150>' => '
#
# Stub version of: \\E[H\\E[J$<150>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '%p1%{8}%/%{6}%*%{4}%+\\E[%d%p1%{8}%m%Pa%?%ga%{1}%=%t4%e%ga%{3}%=%t6%e%ga%{4}%=%t1%e%ga%{6}%=%t3%e%ga%d%;m' => '
#
# Stub version of: %p1%{8}%/%{6}%*%{4}%+\\E[%d%p1%{8}%m%Pa%?%ga%{1}%=%t4%e%ga%{3}%=%t6%e%ga%{4}%=%t1%e%ga%{6}%=%t3%e%ga%d%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  push(@iparam, $param[0]); # %p1
  push(@iparam, 8); # %{8}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 6); # %{6}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 4); # %{4}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  push(@iparam, $param[0]); # %p1
  push(@iparam, 8); # %{8}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  $dynamicp->[0] = pop(@iparam); # %Pa
  if (do { # %?
           push(@iparam, $dynamicp->[0]); # %ga
           push(@iparam, 1); # %{1}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
  }
  else { # %e
    push(@iparam, $dynamicp->[0]); # %ga
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '^B1' => '
#
# Stub version of: ^B1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[~' => '
#
# Stub version of: \\E[~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[219z' => '
#
# Stub version of: \\E[219z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(122); # z

  return $rc;
}
',
          '^B2^J' => '
#
# Stub version of: ^B2^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(50); # 2
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '^]\\345' => '
#
# Stub version of: ^]\\345
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^]
  $rc .= chr(229); # \\345

  return $rc;
}
',
          '\\E?v' => '
#
# Stub version of: \\E?v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\E[30;0;0;30p' => '
#
# Stub version of: \\E[30;0;0;30p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E)0\\016' => '
#
# Stub version of: \\E)0\\016
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(14); # \\016

  return $rc;
}
',
          '\\Ec\\ED' => '
#
# Stub version of: \\Ec\\ED
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\ENo' => '
#
# Stub version of: \\ENo
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\Ew0$<16>' => '
#
# Stub version of: \\Ew0$<16>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E]52;%p1%s;%p2%s\\007' => '
#
# Stub version of: \\E]52;%p1%s;%p2%s\\007
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(53); # 5
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(7); # \\007

  return $rc;
}
',
          '\\E7\\E[r\\E8\\E[m\\E[?7h\\E[?1;3;4;6l\\E[4l\\E>' => '
#
# Stub version of: \\E7\\E[r\\E8\\E[m\\E[?7h\\E[?1;3;4;6l\\E[4l\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E#%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\E#%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\377\\272' => '
#
# Stub version of: \\377\\272
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(186); # \\272

  return $rc;
}
',
          '\\E[?25l' => '
#
# Stub version of: \\E[?25l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EFM' => '
#
# Stub version of: \\EFM
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\E&r%p1%dU' => '
#
# Stub version of: \\E&r%p1%dU
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(114); # r
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(85); # U

  return $rc;
}
',
          '\\E[1;1H\\E[J' => '
#
# Stub version of: \\E[1;1H\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '^\\012\\r' => '
#
# Stub version of: ^\\012\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(10); # \\012
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\ERg' => '
#
# Stub version of: \\ERg
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\0k' => '
#
# Stub version of: \\0k
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(107); # k

  return $rc;
}
',
          '^CA' => '
#
# Stub version of: ^CA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^C
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[%p1%dX' => '
#
# Stub version of: \\E[%p1%dX
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(88); # X

  return $rc;
}
',
          '\\E[?5h\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\E[?5l' => '
#
# Stub version of: \\E[?5h\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\E[?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EARN' => '
#
# Stub version of: \\EARN
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(82); # R
  $rc .= chr(78); # N

  return $rc;
}
',
          '\\E%!1\\E[5m$<2>\\E%!0' => '
#
# Stub version of: \\E%!1\\E[5m$<2>\\E%!0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0

  return $rc;
}
',
          '^P^L' => '
#
# Stub version of: ^P^L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(0); # ^L

  return $rc;
}
',
          '\\E[020z' => '
#
# Stub version of: \\E[020z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E=%p1%{32}%+%c%p2%{32}%+%c$<6>\\EF \\011' => '
#
# Stub version of: \\E=%p1%{32}%+%c%p2%{32}%+%c$<6>\\EF \\011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(32); #  
  $rc .= chr(9); # \\011

  return $rc;
}
',
          '^^}' => '
#
# Stub version of: ^^}
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(125); # }

  return $rc;
}
',
          '\\E[K$<10>' => '
#
# Stub version of: \\E[K$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E<\\E[?2h\\Ev' => '
#
# Stub version of: \\E<\\E[?2h\\Ev
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\E_C\\E\\\\' => '
#
# Stub version of: \\E_C\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E&a%p1%dr%p2%dC' => '
#
# Stub version of: \\E&a%p1%dr%p2%dC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(114); # r
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[6\\^' => '
#
# Stub version of: \\E[6\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\Ea%p1%?%p1%{95}%>%t\\001%{96}%-%;%{32}%+%c%p2%?%p2%{95}%>%t\\001%{96}%-%;%{32}%+%c' => '
#
# Stub version of: \\Ea%p1%?%p1%{95}%>%t\\001%{96}%-%;%{32}%+%c%p2%?%p2%{95}%>%t\\001%{96}%-%;%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 95); # %{95}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    $rc .= chr(1); # \\001
    push(@iparam, 96); # %{96}
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  } # %;
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, 95); # %{95}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    $rc .= chr(1); # \\001
    push(@iparam, 96); # %{96}
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  } # %;
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[;71;30p\\E[;72;11p\\E[;73;27;21p\\E[;77;12p\\E[;80;10p\\E[;81;27;4p\\E[;82;27;27;105p\\E[;83;127p' => '
#
# Stub version of: \\E[;71;30p\\E[;72;11p\\E[;73;27;21p\\E[;77;12p\\E[;80;10p\\E[;81;27;4p\\E[;82;27;27;105p\\E[;83;127p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E)0\\017\\E[m\\E[=107;207h\\E[90;3u\\E[92;3u\\E[43;1u\\177\\E$P\\177\\E[44;1u\\177\\E$Q\\177\\E[45;1u\\177\\E$R\\177\\E[46;1u\\177\\E$S\\177\\E[200;1u\\177\\E$A\\177\\E[201;1u\\177\\E$B\\177\\E[202;1u\\177\\E$C\\177\\E[203;1u\\177\\E$D\\177\\E[204;1u\\177\\E$H\\177\\E[212;1u\\177\\E$I\\177\\E[213;1u\\177\\E$\\010\\177\\E[214;1u"\\E$\\177"\\E[2!w\\E[25;25w\\E[!w\\E[2*w\\E[2+x\\E[;3+}' => '
#
# Stub version of: \\E)0\\017\\E[m\\E[=107;207h\\E[90;3u\\E[92;3u\\E[43;1u\\177\\E$P\\177\\E[44;1u\\177\\E$Q\\177\\E[45;1u\\177\\E$R\\177\\E[46;1u\\177\\E$S\\177\\E[200;1u\\177\\E$A\\177\\E[201;1u\\177\\E$B\\177\\E[202;1u\\177\\E$C\\177\\E[203;1u\\177\\E$D\\177\\E[204;1u\\177\\E$H\\177\\E[212;1u\\177\\E$I\\177\\E[213;1u\\177\\E$\\010\\177\\E[214;1u"\\E$\\177"\\E[2!w\\E[25;25w\\E[!w\\E[2*w\\E[2+x\\E[;3+}
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(80); # P
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(81); # Q
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(82); # R
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(83); # S
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(65); # A
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(66); # B
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(67); # C
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(68); # D
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(72); # H
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(73); # I
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(8); # \\010
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(127); # \\177
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(33); # !
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(43); # +
  $rc .= chr(120); # x
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(43); # +
  $rc .= chr(125); # }

  return $rc;
}
',
          '\\E}' => '
#
# Stub version of: \\E}
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(125); # }

  return $rc;
}
',
          '\\E[2;50m' => '
#
# Stub version of: \\E[2;50m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[6;3~' => '
#
# Stub version of: \\E[6;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[?5l$<50>\\E[?5h' => '
#
# Stub version of: \\E[?5l$<50>\\E[?5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[12h\\E[?10l\\E%/0n\\E[P\\031\\E[?3l\\E(B\\E)0$<200>' => '
#
# Stub version of: \\E[12h\\E[?10l\\E%/0n\\E[P\\031\\E[?3l\\E(B\\E)0$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= chr(48); # 0
  $rc .= chr(110); # n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(80); # P
  $rc .= chr(25); # \\031
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '+\\020\\,\\021-\\030.^Y0\\333`\\004a\\261f\\370g\\361h\\260i\\316j\\331k\\277l\\332m\\300n\\305o~p\\304q\\304r\\304s_t\\303u\\264v\\301w\\302x\\263y\\363z\\362{\\343|\\330}\\234~\\376' => '
#
# Stub version of: +\\020\\,\\021-\\030.^Y0\\333`\\004a\\261f\\370g\\361h\\260i\\316j\\331k\\277l\\332m\\300n\\305o~p\\304q\\304r\\304s_t\\303u\\264v\\301w\\302x\\263y\\363z\\362{\\343|\\330}\\234~\\376
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(16); # \\020
  $rc .= chr(128); # \\,
  $rc .= chr(17); # \\021
  $rc .= chr(45); # -
  $rc .= chr(24); # \\030
  $rc .= chr(46); # .
  $rc .= chr(0); # ^Y
  $rc .= chr(48); # 0
  $rc .= chr(219); # \\333
  $rc .= chr(96); # `
  $rc .= chr(4); # \\004
  $rc .= chr(97); # a
  $rc .= chr(177); # \\261
  $rc .= chr(102); # f
  $rc .= chr(248); # \\370
  $rc .= chr(103); # g
  $rc .= chr(241); # \\361
  $rc .= chr(104); # h
  $rc .= chr(176); # \\260
  $rc .= chr(105); # i
  $rc .= chr(206); # \\316
  $rc .= chr(106); # j
  $rc .= chr(217); # \\331
  $rc .= chr(107); # k
  $rc .= chr(191); # \\277
  $rc .= chr(108); # l
  $rc .= chr(218); # \\332
  $rc .= chr(109); # m
  $rc .= chr(192); # \\300
  $rc .= chr(110); # n
  $rc .= chr(197); # \\305
  $rc .= chr(111); # o
  $rc .= chr(126); # ~
  $rc .= chr(112); # p
  $rc .= chr(196); # \\304
  $rc .= chr(113); # q
  $rc .= chr(196); # \\304
  $rc .= chr(114); # r
  $rc .= chr(196); # \\304
  $rc .= chr(115); # s
  $rc .= chr(95); # _
  $rc .= chr(116); # t
  $rc .= chr(195); # \\303
  $rc .= chr(117); # u
  $rc .= chr(180); # \\264
  $rc .= chr(118); # v
  $rc .= chr(193); # \\301
  $rc .= chr(119); # w
  $rc .= chr(194); # \\302
  $rc .= chr(120); # x
  $rc .= chr(179); # \\263
  $rc .= chr(121); # y
  $rc .= chr(243); # \\363
  $rc .= chr(122); # z
  $rc .= chr(242); # \\362
  $rc .= chr(123); # {
  $rc .= chr(227); # \\343
  $rc .= chr(124); # |
  $rc .= chr(216); # \\330
  $rc .= chr(125); # }
  $rc .= chr(156); # \\234
  $rc .= chr(126); # ~
  $rc .= chr(254); # \\376

  return $rc;
}
',
          '\\E[38;5;%p1%dm' => '
#
# Stub version of: \\E[38;5;%p1%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Ee%p1%{32}%+%c' => '
#
# Stub version of: \\Ee%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\Eg4' => '
#
# Stub version of: \\Eg4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\EFN' => '
#
# Stub version of: \\EFN
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(78); # N

  return $rc;
}
',
          '\\E[=r' => '
#
# Stub version of: \\E[=r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[m' => '
#
# Stub version of: \\E[m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m

  return $rc;
}
',
          '^B4^J' => '
#
# Stub version of: ^B4^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(52); # 4
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '\\233001z' => '
#
# Stub version of: \\233001z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '^_1' => '
#
# Stub version of: ^_1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^_
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[>1;2B' => '
#
# Stub version of: \\E[>1;2B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[%p1%{1}%+%dG' => '
#
# Stub version of: \\E[%p1%{1}%+%dG
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  push(@iparam, 1); # %{1}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[1;24r\\E[24;1H' => '
#
# Stub version of: \\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[1;24r\\E[24;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E#3' => '
#
# Stub version of: \\E#3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\Ew@%p1%{48}%+%c%p2%{32}%+%c%p3%{32}%+%c$<30>' => '
#
# Stub version of: \\Ew@%p1%{48}%+%c%p2%{32}%+%c%p3%{32}%+%c$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(64); # @
  push(@iparam, $param[0]); # %p1
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[2]); # %p3
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EH%p1%c' => '
#
# Stub version of: \\EH%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '^A`' => '
#
# Stub version of: ^A`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(96); # `

  return $rc;
}
',
          '\\E3\\Eb\\Ej\\E\\\\\\El\\EG\\Ed\\Ek' => '
#
# Stub version of: \\E3\\Eb\\Ej\\E\\\\\\El\\EG\\Ed\\Ek
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\EOk' => '
#
# Stub version of: \\EOk
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\E3\\Eb' => '
#
# Stub version of: \\E3\\Eb
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E[>5h' => '
#
# Stub version of: \\E[>5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[5;>;12;18;?<l\\E[=h\\EP1s\\E\\\\\\E[\\027p' => '
#
# Stub version of: \\E[5;>;12;18;?<l\\E[=h\\EP1s\\E\\\\\\E[\\027p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(62); # >
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(60); # <
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(49); # 1
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(23); # \\027
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E%!0\\ETM1\\E%!1\\E[m' => '
#
# Stub version of: \\E%!0\\ETM1\\E%!1\\E[m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(77); # M
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[51m' => '
#
# Stub version of: \\E[51m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[311z' => '
#
# Stub version of: \\E[311z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E\\017$<13>' => '
#
# Stub version of: \\E\\017$<13>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(15); # \\017
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^PF' => '
#
# Stub version of: ^^PF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E[>1;4C' => '
#
# Stub version of: \\E[>1;4C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(67); # C

  return $rc;
}
',
          '~\\021%p2%p2%?%{30}%>%t%{32}%+%;%{96}%+%c%p1%{96}%+%c' => '
#
# Stub version of: ~\\021%p2%p2%?%{30}%>%t%{32}%+%;%{96}%+%c%p1%{96}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(17); # \\021
  push(@iparam, $param[1]); # %p2
  push(@iparam, $param[1]); # %p2
  if (do { # %?
           push(@iparam, 30); # %{30}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, 32); # %{32}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  push(@iparam, 96); # %{96}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 96); # %{96}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[!p\\E[?3;4l\\E[4l\\E>' => '
#
# Stub version of: \\E[!p\\E[?3;4l\\E[4l\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E^U' => '
#
# Stub version of: \\E^U
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^U

  return $rc;
}
',
          '\\E_H\\E\\\\' => '
#
# Stub version of: \\E_H\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E[s\\E[1b' => '
#
# Stub version of: \\E[s\\E[1b
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E[m\\E(B$<5>' => '
#
# Stub version of: \\E[m\\E(B$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\233' => '
#
# Stub version of: \\377\\233
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(155); # \\233

  return $rc;
}
',
          '\\E[1;35r\\E[35;1H' => '
#
# Stub version of: \\E[1;35r\\E[35;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E*B' => '
#
# Stub version of: \\E*B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E5' => '
#
# Stub version of: \\E5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\EN$<0.1*>' => '
#
# Stub version of: \\EN$<0.1*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(48); # 0
  $rc .= chr(46); # .
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[>5h\\E[>9h' => '
#
# Stub version of: \\E[>5h\\E[>9h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(57); # 9
  $rc .= chr(104); # h

  return $rc;
}
',
          '^I\\Ed' => '
#
# Stub version of: ^I\\Ed
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^I
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\Ec\\E[<2h' => '
#
# Stub version of: \\Ec\\E[<2h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[12;4~' => '
#
# Stub version of: \\E[12;4~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[H\\E[J$<156>\\E[36;0;0;36p' => '
#
# Stub version of: \\E[H\\E[J$<156>\\E[36;0;0;36p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[?1003%?%p1%{1}%=%th%el%;' => '
#
# Stub version of: \\E[?1003%?%p1%{1}%=%th%el%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(104); # h
  }
  else { # %e
    $rc .= chr(108); # l
  } # %;

  return $rc;
}
',
          '\\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\E[5;5~' => '
#
# Stub version of: \\E[5;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E%!0\\ETD00\\E%!1' => '
#
# Stub version of: \\E%!0\\ETD00\\E%!1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(68); # D
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E ;\\177' => '
#
# Stub version of: \\E ;\\177
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(59); # ;
  $rc .= chr(127); # \\177

  return $rc;
}
',
          '\\E[7m$<20>' => '
#
# Stub version of: \\E[7m$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Eu\\r' => '
#
# Stub version of: \\Eu\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(117); # u
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^L^R' => '
#
# Stub version of: ^L^R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^L
  $rc .= chr(0); # ^R

  return $rc;
}
',
          '\\EN\\Ed' => '
#
# Stub version of: \\EN\\Ed
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\E&v0m1a1b1c0I\\E&v1a1I\\E&v1b2I\\E&v1a1b3I\\E&v1c4I\\E&v1a1c5I\\E&v1b1c6I\\E&v1x1y7I' => '
#
# Stub version of: \\E&v0m1a1b1c0I\\E&v1a1I\\E&v1b2I\\E&v1a1b3I\\E&v1c4I\\E&v1a1c5I\\E&v1b1c6I\\E&v1x1y7I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(49); # 1
  $rc .= chr(97); # a
  $rc .= chr(49); # 1
  $rc .= chr(98); # b
  $rc .= chr(49); # 1
  $rc .= chr(99); # c
  $rc .= chr(48); # 0
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(49); # 1
  $rc .= chr(97); # a
  $rc .= chr(49); # 1
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(49); # 1
  $rc .= chr(98); # b
  $rc .= chr(50); # 2
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(49); # 1
  $rc .= chr(97); # a
  $rc .= chr(49); # 1
  $rc .= chr(98); # b
  $rc .= chr(51); # 3
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(49); # 1
  $rc .= chr(99); # c
  $rc .= chr(52); # 4
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(49); # 1
  $rc .= chr(97); # a
  $rc .= chr(49); # 1
  $rc .= chr(99); # c
  $rc .= chr(53); # 5
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(49); # 1
  $rc .= chr(98); # b
  $rc .= chr(49); # 1
  $rc .= chr(99); # c
  $rc .= chr(54); # 6
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(49); # 1
  $rc .= chr(120); # x
  $rc .= chr(49); # 1
  $rc .= chr(121); # y
  $rc .= chr(55); # 7
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\E[%?%p1%{8}%<%t4%e=%;%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m' => '
#
# Stub version of: \\E[%?%p1%{8}%<%t4%e=%;%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 8); # %{8}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
  }
  else { # %e
    $rc .= chr(61); # =
  } # %;
  push(@iparam, $param[0]); # %p1
  push(@iparam, 2); # %{2}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 4); # %{4}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  if (do { # %?
           push(@iparam, $staticp->[3]); # %gD
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[20]); # %gU
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[1]); # %gB
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[17]); # %gR
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '^\\037\\r' => '
#
# Stub version of: ^\\037\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(31); # \\037
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E<\\E\\^5;2s\\E\\^7;1s\\E[3g\\E\\^11;9s\\E\\^11;17s\\E\\^11;25s\\E\\^11;33s\\E\\^11;41s\\E\\^11;49s\\E\\^11;57s\\E\\^11;65s\\E\\^11;73s\\E\\^11;81s\\E\\^11;89s\\E\\^12;0s\\E\\^14;2s\\E\\^15;9s\\E\\^25;1s\\E\\^9;1s\\E\\^27;1' => '
#
# Stub version of: \\E<\\E\\^5;2s\\E\\^7;1s\\E[3g\\E\\^11;9s\\E\\^11;17s\\E\\^11;25s\\E\\^11;33s\\E\\^11;41s\\E\\^11;49s\\E\\^11;57s\\E\\^11;65s\\E\\^11;73s\\E\\^11;81s\\E\\^11;89s\\E\\^12;0s\\E\\^14;2s\\E\\^15;9s\\E\\^25;1s\\E\\^9;1s\\E\\^27;1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(55); # 7
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(49); # 1
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(57); # 9
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[2!w\\E[%i%p1%dG' => '
#
# Stub version of: \\E[2!w\\E[%i%p1%dG
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(33); # !
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\EOe' => '
#
# Stub version of: \\EOe
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\E&j@' => '
#
# Stub version of: \\E&j@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(106); # j
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E!%p1%02d' => '
#
# Stub version of: \\E!%p1%02d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%02d\', pop(@iparam)); # %02d

  return $rc;
}
',
          '\\034Y$<3*>' => '
#
# Stub version of: \\034Y$<3*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(28); # \\034
  $rc .= chr(89); # Y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EK$<3/>' => '
#
# Stub version of: \\EK$<3/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[3;5~' => '
#
# Stub version of: \\E[3;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[5p' => '
#
# Stub version of: \\E[5p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E7\\E[255;0;0;33;80;80p\\E8\\E[J' => '
#
# Stub version of: \\E7\\E[255;0;0;33;80;80p\\E8\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\215' => '
#
# Stub version of: \\215
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(141); # \\215

  return $rc;
}
',
          '\\E[6r' => '
#
# Stub version of: \\E[6r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[P$<3>' => '
#
# Stub version of: \\E[P$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&w13F$<66/>\\E&w12F$<66/>\\E&w13F$<66/>\\E&w12F' => '
#
# Stub version of: \\E&w13F$<66/>\\E&w12F$<66/>\\E&w13F$<66/>\\E&w12F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(70); # F
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(70); # F
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(70); # F
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\EW\\r' => '
#
# Stub version of: \\EW\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^^s' => '
#
# Stub version of: ^^s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E[>h' => '
#
# Stub version of: \\E[>h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EC%p2%c%p1%c' => '
#
# Stub version of: \\EC%p2%c%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\23335~' => '
#
# Stub version of: \\23335~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E(\\Ek' => '
#
# Stub version of: \\E(\\Ek
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\E[1;3P' => '
#
# Stub version of: \\E[1;3P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E%%!1\\E[%?%p1%t;7;5%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t<0%;%?%p6%t;1%;m$<2>\\E%%!0' => '
#
# Stub version of: \\E%%!1\\E[%?%p1%t;7;5%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t<0%;%?%p6%t;1%;m$<2>\\E%%!0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= \'%\';
  $rc .= chr(33); # !
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(60); # <
    $rc .= chr(48); # 0
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= \'%\';
  $rc .= chr(33); # !
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[007q' => '
#
# Stub version of: \\E[007q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E<\\E2\\E[20l\\E[?6l\\E[r\\E[m\\E[q\\E(B\\017\\E)0\\E>' => '
#
# Stub version of: \\E<\\E2\\E[20l\\E[?6l\\E[r\\E[m\\E[q\\E(B\\017\\E)0\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\023\\E1' => '
#
# Stub version of: \\E\\023\\E1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[8;2~' => '
#
# Stub version of: \\E[8;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[0;31;47m' => '
#
# Stub version of: \\E[0;31;47m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EC\\E.3\\EDF\\EV1\\Eg\\E[0ZZ' => '
#
# Stub version of: \\EC\\E.3\\EDF\\EV1\\Eg\\E[0ZZ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(90); # Z
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\010$<2>' => '
#
# Stub version of: \\010$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(8); # \\010
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO1;7D' => '
#
# Stub version of: \\EO1;7D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\ER\\E0`\\EV' => '
#
# Stub version of: \\ER\\E0`\\EV
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(96); # `
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V

  return $rc;
}
',
          '^^c' => '
#
# Stub version of: ^^c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(99); # c

  return $rc;
}
',
          'g' => '
#
# Stub version of: g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(103); # g

  return $rc;
}
',
          '\\030\\E[H\\E[2J' => '
#
# Stub version of: \\030\\E[H\\E[2J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(24); # \\030
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[4A' => '
#
# Stub version of: \\E[4A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E>\\E[?1h\\E[?7h\\E[?5l\\017\\E(B\\E[m\\E[20l\\E[1;24r\\E[24;1H' => '
#
# Stub version of: \\E>\\E[?1h\\E[?7h\\E[?5l\\017\\E(B\\E[m\\E[20l\\E[1;24r\\E[24;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[?21l' => '
#
# Stub version of: \\E[?21l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\035rig %p1%d;' => '
#
# Stub version of: \\035rig %p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(114); # r
  $rc .= chr(105); # i
  $rc .= chr(103); # g
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\EO1;5Q' => '
#
# Stub version of: \\EO1;5Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E[1;0x\\E[2;7x' => '
#
# Stub version of: \\E[1;0x\\E[2;7x
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(120); # x
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\EF2' => '
#
# Stub version of: \\EF2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\EF\\r' => '
#
# Stub version of: \\EF\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[155q' => '
#
# Stub version of: \\E[155q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[2K' => '
#
# Stub version of: \\E[2K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E[1S' => '
#
# Stub version of: \\E[1S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E=\\E[?1h' => '
#
# Stub version of: \\E=\\E[?1h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[204z' => '
#
# Stub version of: \\E[204z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EO\\Eq' => '
#
# Stub version of: \\EO\\Eq
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[022q' => '
#
# Stub version of: \\E[022q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E!\\r$<20>' => '
#
# Stub version of: \\E!\\r$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(13); # \\r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO\\^' => '
#
# Stub version of: \\EO\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\E[P$<4/>' => '
#
# Stub version of: \\E[P$<4/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0 p' => '
#
# Stub version of: \\E[0 p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(32); #  
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\ENy' => '
#
# Stub version of: \\ENy
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(121); # y

  return $rc;
}
',
          '\\E[12;6~' => '
#
# Stub version of: \\E[12;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EG0\\E[=5h' => '
#
# Stub version of: \\EG0\\E[=5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E\\s\\s' => '
#
# Stub version of: \\E\\s\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(32); # \\s
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E[33;2~' => '
#
# Stub version of: \\E[33;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\r\\E[H\\E[A\\n' => '
#
# Stub version of: \\r\\E[H\\E[A\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\Ec\\E[?3l\\E[2;0y' => '
#
# Stub version of: \\Ec\\E[?3l\\E[2;0y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(121); # y

  return $rc;
}
',
          '\\233105z' => '
#
# Stub version of: \\233105z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(122); # z

  return $rc;
}
',
          '.1*\\E\'D' => '
#
# Stub version of: .1*\\E\'D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(46); # .
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[;%{1}%p1%+%ds' => '
#
# Stub version of: \\E[;%{1}%p1%+%ds
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  push(@iparam, 1); # %{1}
  push(@iparam, $param[0]); # %p1
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(115); # s

  return $rc;
}
',
          '-SRCH' => '
#
# Stub version of: -SRCH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(45); # -
  $rc .= chr(83); # S
  $rc .= chr(82); # R
  $rc .= chr(67); # C
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E=%p1%{32}%+%c%p2%{80}%m%{32}%+%c%p2%{80}%>%{32}%+%c' => '
#
# Stub version of: \\E=%p1%{32}%+%c%p2%{80}%m%{32}%+%c%p2%{80}%>%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 80); # %{80}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 80); # %{80}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\017\\E[=1w' => '
#
# Stub version of: \\017\\E[=1w
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\E[35h\\E[?3h' => '
#
# Stub version of: \\E[35h\\E[?3h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\Eb\\r' => '
#
# Stub version of: \\Eb\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E0@' => '
#
# Stub version of: \\E0@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\0U' => '
#
# Stub version of: \\0U
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(85); # U

  return $rc;
}
',
          '\\ESTART\\r\\E37\\r\\EEND\\r$<1>' => '
#
# Stub version of: \\ESTART\\r\\E37\\r\\EEND\\r$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(84); # T
  $rc .= chr(65); # A
  $rc .= chr(82); # R
  $rc .= chr(84); # T
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(55); # 7
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(78); # N
  $rc .= chr(68); # D
  $rc .= chr(13); # \\r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\233%i%p1%dd' => '
#
# Stub version of: \\233%i%p1%dd
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\E[144q' => '
#
# Stub version of: \\E[144q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E?d' => '
#
# Stub version of: \\E?d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\E[?31h' => '
#
# Stub version of: \\E[?31h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[24;5~' => '
#
# Stub version of: \\E[24;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[7\\^' => '
#
# Stub version of: \\E[7\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\036\\022B\\003\\036\\035\\017\\022\\025\\035\\036E\\036\\022H\\036\\022J\\036\\022L\\036\\022N\\036\\022P\\036\\022Q\\036\\022\\036\\022\\^\\036\\022b\\036\\022i\\036W =\\036\\022Z\\036\\011C1-` `!k/o' => '
#
# Stub version of: \\036\\022B\\003\\036\\035\\017\\022\\025\\035\\036E\\036\\022H\\036\\022J\\036\\022L\\036\\022N\\036\\022P\\036\\022Q\\036\\022\\036\\022\\^\\036\\022b\\036\\022i\\036W =\\036\\022Z\\036\\011C1-` `!k/o
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(18); # \\022
  $rc .= chr(66); # B
  $rc .= chr(3); # \\003
  $rc .= chr(30); # \\036
  $rc .= chr(29); # \\035
  $rc .= chr(15); # \\017
  $rc .= chr(18); # \\022
  $rc .= chr(21); # \\025
  $rc .= chr(29); # \\035
  $rc .= chr(30); # \\036
  $rc .= chr(69); # E
  $rc .= chr(30); # \\036
  $rc .= chr(18); # \\022
  $rc .= chr(72); # H
  $rc .= chr(30); # \\036
  $rc .= chr(18); # \\022
  $rc .= chr(74); # J
  $rc .= chr(30); # \\036
  $rc .= chr(18); # \\022
  $rc .= chr(76); # L
  $rc .= chr(30); # \\036
  $rc .= chr(18); # \\022
  $rc .= chr(78); # N
  $rc .= chr(30); # \\036
  $rc .= chr(18); # \\022
  $rc .= chr(80); # P
  $rc .= chr(30); # \\036
  $rc .= chr(18); # \\022
  $rc .= chr(81); # Q
  $rc .= chr(30); # \\036
  $rc .= chr(18); # \\022
  $rc .= chr(30); # \\036
  $rc .= chr(18); # \\022
  $rc .= chr(128); # \\^
  $rc .= chr(30); # \\036
  $rc .= chr(18); # \\022
  $rc .= chr(98); # b
  $rc .= chr(30); # \\036
  $rc .= chr(18); # \\022
  $rc .= chr(105); # i
  $rc .= chr(30); # \\036
  $rc .= chr(87); # W
  $rc .= chr(32); #  
  $rc .= chr(61); # =
  $rc .= chr(30); # \\036
  $rc .= chr(18); # \\022
  $rc .= chr(90); # Z
  $rc .= chr(30); # \\036
  $rc .= chr(9); # \\011
  $rc .= chr(67); # C
  $rc .= chr(49); # 1
  $rc .= chr(45); # -
  $rc .= chr(96); # `
  $rc .= chr(32); #  
  $rc .= chr(96); # `
  $rc .= chr(33); # !
  $rc .= chr(107); # k
  $rc .= chr(47); # /
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\E0;2m\\E[1;25r\\E[25;1H\\E[?3l\\E[?7h\\E[?8h' => '
#
# Stub version of: \\E0;2m\\E[1;25r\\E[25;1H\\E[?3l\\E[?7h\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\001$<20*>' => '
#
# Stub version of: \\001$<20*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(1); # \\001
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EC\\EX\\EA\\E%\\E9\\Ee\\Er\\En\\E"\\E}\\E\'\\E(\\Ef\\r\\Ek\\Eq\\Em' => '
#
# Stub version of: \\EC\\EX\\EA\\E%\\E9\\Ee\\Er\\En\\E"\\E}\\E\'\\E(\\Ef\\r\\Ek\\Eq\\Em
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(110); # n
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(125); # }
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[4h$<80>' => '
#
# Stub version of: \\E[4h$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[230z' => '
#
# Stub version of: \\E[230z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E(B\\E[20l\\E[w\\E[0;132s\\E[2g\\E[z\\E[66t\\E[1;66r\\E[4g\\E>' => '
#
# Stub version of: \\E(B\\E[20l\\E[w\\E[0;132s\\E[2g\\E[z\\E[66t\\E[1;66r\\E[4g\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(122); # z
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(116); # t
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E%\\014\\014\\014\\016\\003\\0\\003\\002\\003\\002\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0' => '
#
# Stub version of: \\E%\\014\\014\\014\\016\\003\\0\\003\\002\\003\\002\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(12); # \\014
  $rc .= chr(12); # \\014
  $rc .= chr(12); # \\014
  $rc .= chr(14); # \\016
  $rc .= chr(3); # \\003
  $rc .= chr(128); # \\0
  $rc .= chr(3); # \\003
  $rc .= chr(2); # \\002
  $rc .= chr(3); # \\003
  $rc .= chr(2); # \\002
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0

  return $rc;
}
',
          '\\E_1\\E\\\\' => '
#
# Stub version of: \\E_1\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\233[?1;2c' => '
#
# Stub version of: \\233[?1;2c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(99); # c

  return $rc;
}
',
          'PF7' => '
#
# Stub version of: PF7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(80); # P
  $rc .= chr(70); # F
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\004%p1%d;%p2%d;' => '
#
# Stub version of: \\004%p1%d;%p2%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(4); # \\004
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[7C' => '
#
# Stub version of: \\E[7C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E%%' => '
#
# Stub version of: \\E%%
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= \'%\';

  return $rc;
}
',
          '\\EW$<2>' => '
#
# Stub version of: \\EW$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^\\^' => '
#
# Stub version of: ^^\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\E[!p\\E[?3;7;19;67h\\E[?1;4l\\E[1;0%w\\E(B\\E)0\\017\\E[2J\\E[1;1H\\E>$<200>' => '
#
# Stub version of: \\E[!p\\E[?3;7;19;67h\\E[?1;4l\\E[1;0%w\\E(B\\E)0\\017\\E[2J\\E[1;1H\\E>$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(37); # %
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[158q' => '
#
# Stub version of: \\E[158q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(56); # 8
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\020\\002$<200/>\\020\\003' => '
#
# Stub version of: \\020\\002$<200/>\\020\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  $rc .= chr(2); # \\002
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(16); # \\020
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '\\034Q$<5>' => '
#
# Stub version of: \\034Q$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(28); # \\034
  $rc .= chr(81); # Q
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&dF' => '
#
# Stub version of: \\E&dF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%O%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p7%t;8%;m\\E[%?%p8%t1%;"q%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%O%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p7%t;8%;m\\E[%?%p8%t1%;"q%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) || pop(@iparam)); # %O
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[7]); # %p8
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(34); # "
  $rc .= chr(113); # q
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\2331T' => '
#
# Stub version of: \\2331T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\E>\\E[?3h\\E[?4l\\E[?5l\\E[?7l\\E[?8h\\E[1;24r\\E[24;1H' => '
#
# Stub version of: \\E>\\E[?3h\\E[?4l\\E[?5l\\E[?7l\\E[?8h\\E[1;24r\\E[24;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '^P ^P' => '
#
# Stub version of: ^P ^P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(32); #  
  $rc .= chr(0); # ^P

  return $rc;
}
',
          '\\Ej$<1>' => '
#
# Stub version of: \\Ej$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[H\\E[J$<110>' => '
#
# Stub version of: \\E[H\\E[J$<110>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO5P' => '
#
# Stub version of: \\EO5P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(53); # 5
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\ELZ' => '
#
# Stub version of: \\ELZ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\E[%i%p1%02d;%p2%02dH' => '
#
# Stub version of: \\E[%i%p1%02d;%p2%02dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%02d\', pop(@iparam)); # %02d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%02d\', pop(@iparam)); # %02d
  $rc .= chr(72); # H

  return $rc;
}
',
          '~\\021%p2%c%p1%c$<1>' => '
#
# Stub version of: ~\\021%p2%c%p1%c$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(17); # \\021
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '^V\'^A' => '
#
# Stub version of: ^V\'^A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(39); # \'
  $rc .= chr(0); # ^A

  return $rc;
}
',
          '\\020\\032\\030\\035$<10*>' => '
#
# Stub version of: \\020\\032\\030\\035$<10*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  $rc .= chr(26); # \\032
  $rc .= chr(24); # \\030
  $rc .= chr(29); # \\035
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^$' => '
#
# Stub version of: ^^$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\E[301z' => '
#
# Stub version of: \\E[301z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E@%p1%Pb%gb%gf%d%d' => '
#
# Stub version of: \\E@%p1%Pb%gb%gf%d%d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(64); # @
  push(@iparam, $param[0]); # %p1
  $dynamicp->[1] = pop(@iparam); # %Pb
  push(@iparam, $dynamicp->[1]); # %gb
  push(@iparam, $dynamicp->[5]); # %gf
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d

  return $rc;
}
',
          '\\E[34l' => '
#
# Stub version of: \\E[34l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[50m' => '
#
# Stub version of: \\E[50m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[>4h' => '
#
# Stub version of: \\E[>4h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(52); # 4
  $rc .= chr(104); # h

  return $rc;
}
',
          '%i\\E[%p1%d;%p2%dH' => '
#
# Stub version of: %i\\E[%p1%d;%p2%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  map {$param[$_]++} (0..$#param); # %i
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          '^\\034\\r' => '
#
# Stub version of: ^\\034\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(28); # \\034
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EG3' => '
#
# Stub version of: \\EG3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(51); # 3

  return $rc;
}
',
          'F8' => '
#
# Stub version of: F8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(56); # 8

  return $rc;
}
',
          '^Z5' => '
#
# Stub version of: ^Z5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Z
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\247' => '
#
# Stub version of: \\247
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(167); # \\247

  return $rc;
}
',
          '\\036DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD\\037' => '
#
# Stub version of: \\036DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD\\037
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(31); # \\037

  return $rc;
}
',
          '\\E[<1l' => '
#
# Stub version of: \\E[<1l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\0b' => '
#
# Stub version of: \\0b
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E[3%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m' => '
#
# Stub version of: \\E[3%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  push(@iparam, $param[0]); # %p1
  push(@iparam, 2); # %{2}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 4); # %{4}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  if (do { # %?
           push(@iparam, $staticp->[3]); # %gD
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[20]); # %gU
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[1]); # %gB
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[17]); # %gR
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[17;6~' => '
#
# Stub version of: \\E[17;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[1Z' => '
#
# Stub version of: \\E[1Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(90); # Z

  return $rc;
}
',
          '^O\\0c' => '
#
# Stub version of: ^O\\0c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^O
  $rc .= chr(128); # \\0
  $rc .= chr(99); # c

  return $rc;
}
',
          '^Ae\\r' => '
#
# Stub version of: ^Ae\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(101); # e
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[5$' => '
#
# Stub version of: \\E[5$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\EO2R' => '
#
# Stub version of: \\EO2R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(50); # 2
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\EQ' => '
#
# Stub version of: \\EQ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E^E' => '
#
# Stub version of: \\E^E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^E

  return $rc;
}
',
          '\\E[60;0;0;24p\\E[60;1H\\E[K' => '
#
# Stub version of: \\E[60;0;0;24p\\E[60;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\EM\\s' => '
#
# Stub version of: \\EM\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E*1' => '
#
# Stub version of: \\E*1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\377\\325' => '
#
# Stub version of: \\377\\325
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(213); # \\325

  return $rc;
}
',
          '\\E[?5h$<50>\\E[?5l' => '
#
# Stub version of: \\E[?5h$<50>\\E[?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\Ee6\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`\\:\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<100>' => '
#
# Stub version of: \\Ee6\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`\\:\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(55); # 7
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ea$' => '
#
# Stub version of: \\Ea$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(97); # a
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\233003z' => '
#
# Stub version of: \\233003z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E!k\\r' => '
#
# Stub version of: \\E!k\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(107); # k
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[0p' => '
#
# Stub version of: \\E[0p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\016$<90>' => '
#
# Stub version of: \\016$<90>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(57); # 9
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          'A funcl0=A send' => '
#
# Stub version of: A funcl0=A send
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(65); # A
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(117); # u
  $rc .= chr(110); # n
  $rc .= chr(99); # c
  $rc .= chr(108); # l
  $rc .= chr(48); # 0
  $rc .= chr(61); # =
  $rc .= chr(65); # A
  $rc .= chr(32); #  
  $rc .= chr(115); # s
  $rc .= chr(101); # e
  $rc .= chr(110); # n
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\E[%p1%dC$<1>' => '
#
# Stub version of: \\E[%p1%dC$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '^V' => '
#
# Stub version of: ^V
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V

  return $rc;
}
',
          '\\014$<300/>' => '
#
# Stub version of: \\014$<300/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '/usr/share/tabset/vt100' => '
#
# Stub version of: /usr/share/tabset/vt100
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(47); # /
  $rc .= chr(117); # u
  $rc .= chr(115); # s
  $rc .= chr(114); # r
  $rc .= chr(47); # /
  $rc .= chr(115); # s
  $rc .= chr(104); # h
  $rc .= chr(97); # a
  $rc .= chr(114); # r
  $rc .= chr(101); # e
  $rc .= chr(47); # /
  $rc .= chr(116); # t
  $rc .= chr(97); # a
  $rc .= chr(98); # b
  $rc .= chr(115); # s
  $rc .= chr(101); # e
  $rc .= chr(116); # t
  $rc .= chr(47); # /
  $rc .= chr(118); # v
  $rc .= chr(116); # t
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[>1;3B' => '
#
# Stub version of: \\E[>1;3B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[159q' => '
#
# Stub version of: \\E[159q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(57); # 9
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[%p1%d;1u#%p2%s#' => '
#
# Stub version of: \\E[%p1%d;1u#%p2%s#
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(117); # u
  $rc .= chr(35); # #
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(35); # #

  return $rc;
}
',
          '\\EO1;6D' => '
#
# Stub version of: \\EO1;6D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\037%p1%{65}%+%c%p2%{65}%+%c' => '
#
# Stub version of: \\037%p1%{65}%+%c%p2%{65}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  push(@iparam, $param[0]); # %p1
  push(@iparam, 65); # %{65}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 65); # %{65}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\036A%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%{48}%+%c' => '
#
# Stub version of: \\036A%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%{48}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(65); # A
  push(@iparam, $param[0]); # %p1
  push(@iparam, 2); # %{2}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 4); # %{4}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '4\\,4' => '
#
# Stub version of: 4\\,4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(52); # 4
  $rc .= chr(128); # \\,
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\E<\\E=\\E[?3h\\E[?7h\\E(B\\E[J\\E7\\E[;r\\E8\\E[m\\E[q' => '
#
# Stub version of: \\E<\\E=\\E[?3h\\E[?7h\\E(B\\E[J\\E7\\E[;r\\E8\\E[m\\E[q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E*$<75>' => '
#
# Stub version of: \\E*$<75>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&f2a%p1%dk%p2%l%dL%p2%s' => '
#
# Stub version of: \\E&f2a%p1%dk%p2%l%dL%p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(102); # f
  $rc .= chr(50); # 2
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(107); # k
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '+\\^\\,Q-S.M0\\177`+a\\:f\'g#h#i#jXkClJmFnNo~qUs_tEuPv\\\\wKxW~_' => '
#
# Stub version of: +\\^\\,Q-S.M0\\177`+a\\:f\'g#h#i#jXkClJmFnNo~qUs_tEuPv\\\\wKxW~_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(128); # \\^
  $rc .= chr(128); # \\,
  $rc .= chr(81); # Q
  $rc .= chr(45); # -
  $rc .= chr(83); # S
  $rc .= chr(46); # .
  $rc .= chr(77); # M
  $rc .= chr(48); # 0
  $rc .= chr(127); # \\177
  $rc .= chr(96); # `
  $rc .= chr(43); # +
  $rc .= chr(97); # a
  $rc .= chr(128); # \\:
  $rc .= chr(102); # f
  $rc .= chr(39); # \'
  $rc .= chr(103); # g
  $rc .= chr(35); # #
  $rc .= chr(104); # h
  $rc .= chr(35); # #
  $rc .= chr(105); # i
  $rc .= chr(35); # #
  $rc .= chr(106); # j
  $rc .= chr(88); # X
  $rc .= chr(107); # k
  $rc .= chr(67); # C
  $rc .= chr(108); # l
  $rc .= chr(74); # J
  $rc .= chr(109); # m
  $rc .= chr(70); # F
  $rc .= chr(110); # n
  $rc .= chr(78); # N
  $rc .= chr(111); # o
  $rc .= chr(126); # ~
  $rc .= chr(113); # q
  $rc .= chr(85); # U
  $rc .= chr(115); # s
  $rc .= chr(95); # _
  $rc .= chr(116); # t
  $rc .= chr(69); # E
  $rc .= chr(117); # u
  $rc .= chr(80); # P
  $rc .= chr(118); # v
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(119); # w
  $rc .= chr(75); # K
  $rc .= chr(120); # x
  $rc .= chr(87); # W
  $rc .= chr(126); # ~
  $rc .= chr(95); # _

  return $rc;
}
',
          '\\233202z' => '
#
# Stub version of: \\233202z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[?1049l' => '
#
# Stub version of: \\E[?1049l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\ES%?%p1%t\\ET%;%?%p2%t\\EV%;%?%p3%t\\ET%;%?%p4%t\\EW%;%?%p6%t\\EU%;' => '
#
# Stub version of: \\ES%?%p1%t\\ET%;%?%p2%t\\EV%;%?%p3%t\\ET%;%?%p4%t\\EW%;%?%p6%t\\EU%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(84); # T
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(86); # V
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(84); # T
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(87); # W
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(85); # U
  } # %;

  return $rc;
}
',
          '\\233104z' => '
#
# Stub version of: \\233104z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[00u\\E[<>001001024080072080u\\E[01u' => '
#
# Stub version of: \\E[00u\\E[<>001001024080072080u\\E[01u
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(62); # >
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\E[m\\E7\\E[H\\E9\\E8' => '
#
# Stub version of: \\E[m\\E7\\E[H\\E9\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[%p1%{40}%+%cm' => '
#
# Stub version of: \\E[%p1%{40}%+%cm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  push(@iparam, 40); # %{40}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[%p1%d@$<250>' => '
#
# Stub version of: \\E[%p1%d@$<250>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(64); # @
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ez(\\r' => '
#
# Stub version of: \\Ez(\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(40); # (
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[?1l\\E>\\E[?7h\\E[100g\\E[0m\\E7\\E[r\\E8' => '
#
# Stub version of: \\E[?1l\\E>\\E[?7h\\E[100g\\E[0m\\E7\\E[r\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\2330q' => '
#
# Stub version of: \\2330q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\Ec21\\Ec31' => '
#
# Stub version of: \\Ec21\\Ec31
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\EH\\EJ$<3>' => '
#
# Stub version of: \\EH\\EJ$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\2330x' => '
#
# Stub version of: \\2330x
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\E[31l' => '
#
# Stub version of: \\E[31l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(108); # l

  return $rc;
}
',
          '^_..' => '
#
# Stub version of: ^_..
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^_
  $rc .= chr(46); # .
  $rc .= chr(46); # .

  return $rc;
}
',
          '\\2334i' => '
#
# Stub version of: \\2334i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(52); # 4
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E[30h\\E\\,\\E[30l$<100>' => '
#
# Stub version of: \\E[30h\\E\\,\\E[30l$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\,
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\376B\\001$<200>\\376F' => '
#
# Stub version of: \\376B\\001$<200>\\376F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(254); # \\376
  $rc .= chr(66); # B
  $rc .= chr(1); # \\001
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(254); # \\376
  $rc .= chr(70); # F

  return $rc;
}
',
          '^VA\\r' => '
#
# Stub version of: ^VA\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(65); # A
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^Aa\\r' => '
#
# Stub version of: ^Aa\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(97); # a
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%p1%dM$<70>' => '
#
# Stub version of: \\E[%p1%dM$<70>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          'f5' => '
#
# Stub version of: f5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(102); # f
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E+$<100>' => '
#
# Stub version of: \\E+$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\036FQ2\\036FW\\036F\\^\\036FX004?\\036F]\\036O\\036FS00' => '
#
# Stub version of: \\036FQ2\\036FW\\036F\\^\\036FX004?\\036F]\\036O\\036FS00
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(81); # Q
  $rc .= chr(50); # 2
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(87); # W
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(128); # \\^
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(88); # X
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(63); # ?
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(93); # ]
  $rc .= chr(30); # \\036
  $rc .= chr(79); # O
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[T' => '
#
# Stub version of: \\E[T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\E[%p1%d;%p2%l%02dq%?%p1%{9}%<%t   F%p1%1d           %;%p2%s' => '
#
# Stub version of: \\E[%p1%d;%p2%l%02dq%?%p1%{9}%<%t   F%p1%1d           %;%p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%02d\', pop(@iparam)); # %02d
  $rc .= chr(113); # q
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 9); # %{9}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(70); # F
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%1d\', pop(@iparam)); # %1d
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
  } # %;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\EOI' => '
#
# Stub version of: \\EOI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\E[005q' => '
#
# Stub version of: \\E[005q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E~W' => '
#
# Stub version of: \\E~W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\013%p1%{32}%+%c' => '
#
# Stub version of: \\013%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\EF \\EF\\025' => '
#
# Stub version of: \\EF \\EF\\025
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(21); # \\025

  return $rc;
}
',
          '\\ES' => '
#
# Stub version of: \\ES
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\Ei9' => '
#
# Stub version of: \\Ei9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(105); # i
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\E[!p\\E[?3;7;19;67h\\E[?4l\\E[1;0%w\\E(B\\E)0\\017\\E[2J\\E[1;1H$<200>' => '
#
# Stub version of: \\E[!p\\E[?3;7;19;67h\\E[?4l\\E[1;0%w\\E(B\\E)0\\017\\E[2J\\E[1;1H$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(37); # %
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&d%{0}%Pa%?%p4%t%{1}%ga%+%Pa%;%?%p1%p3%|%p6%|%t%{2}%ga%+%Pa%;%?%p2%p6%|%t%{4}%ga%+%Pa%;%?%p1%p5%|%t%{8}%ga%+%Pa%;%?%p7%t%?%ga%ts%ga%{64}%+%e%{83}%;%e%?%ga%t%ga%{64}%+%e%{64}%;%;%c' => '
#
# Stub version of: \\E&d%{0}%Pa%?%p4%t%{1}%ga%+%Pa%;%?%p1%p3%|%p6%|%t%{2}%ga%+%Pa%;%?%p2%p6%|%t%{4}%ga%+%Pa%;%?%p1%p5%|%t%{8}%ga%+%Pa%;%?%p7%t%?%ga%ts%ga%{64}%+%e%{83}%;%e%?%ga%t%ga%{64}%+%e%{64}%;%;%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  push(@iparam, 0); # %{0}
  $dynamicp->[0] = pop(@iparam); # %Pa
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, $dynamicp->[0]); # %ga
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $dynamicp->[0] = pop(@iparam); # %Pa
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
    push(@iparam, $dynamicp->[0]); # %ga
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $dynamicp->[0] = pop(@iparam); # %Pa
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, $dynamicp->[0]); # %ga
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $dynamicp->[0] = pop(@iparam); # %Pa
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 8); # %{8}
    push(@iparam, $dynamicp->[0]); # %ga
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $dynamicp->[0] = pop(@iparam); # %Pa
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    if (do { # %?
             push(@iparam, $dynamicp->[0]); # %ga
             pop(@iparam);
           }) { # %t
      $rc .= chr(115); # s
      push(@iparam, $dynamicp->[0]); # %ga
      push(@iparam, 64); # %{64}
      push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    }
    else { # %e
      push(@iparam, 83); # %{83}
    } # %;
  }
  else { # %e
    if (do { # %?
             push(@iparam, $dynamicp->[0]); # %ga
             pop(@iparam);
           }) { # %t
      push(@iparam, $dynamicp->[0]); # %ga
      push(@iparam, 64); # %{64}
      push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    }
    else { # %e
      push(@iparam, 64); # %{64}
    } # %;
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '^Q' => '
#
# Stub version of: ^Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Q

  return $rc;
}
',
          '\\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;11%;m' => '
#
# Stub version of: \\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;11%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E<\\E[>1;3;5;6;7l\\E[0m\\E[2J' => '
#
# Stub version of: \\E<\\E[>1;3;5;6;7l\\E[0m\\E[2J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[3g' => '
#
# Stub version of: \\E[3g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7l\\E[?8h' => '
#
# Stub version of: \\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7l\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EO3A' => '
#
# Stub version of: \\EO3A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(51); # 3
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%d%%v' => '
#
# Stub version of: \\E[%i%p1%d;%p2%d%%v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= \'%\';
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\E[J$<8*>' => '
#
# Stub version of: \\E[J$<8*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\233010z' => '
#
# Stub version of: \\233010z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\23320~' => '
#
# Stub version of: \\23320~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[U\\E[?38l' => '
#
# Stub version of: \\E[U\\E[?38l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(56); # 8
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\Ej\\r' => '
#
# Stub version of: \\Ej\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[305z' => '
#
# Stub version of: \\E[305z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[%?%p1%{8}%>%t%\'F\'%p1%+%d%e4%p1%d%;m' => '
#
# Stub version of: \\E[%?%p1%{8}%>%t%\'F\'%p1%+%d%e4%p1%d%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 8); # %{8}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, chr(70)); # %\'F\'
    push(@iparam, $param[0]); # %p1
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  }
  else { # %e
    $rc .= chr(52); # 4
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E@$<10>' => '
#
# Stub version of: \\E@$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(64); # @
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\024%p1%{24}%+%c%p2%p2%?%{32}%>%t%{48}%+%;%{80}%+%c' => '
#
# Stub version of: \\024%p1%{24}%+%c%p2%p2%?%{32}%>%t%{48}%+%;%{80}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(20); # \\024
  push(@iparam, $param[0]); # %p1
  push(@iparam, 24); # %{24}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, $param[1]); # %p2
  if (do { # %?
           push(@iparam, 32); # %{32}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, 48); # %{48}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  push(@iparam, 80); # %{80}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\Ej\\EYA \\EI\\Ek' => '
#
# Stub version of: \\Ej\\EYA \\EI\\Ek
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(65); # A
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k

  return $rc;
}
',
          'Num +' => '
#
# Stub version of: Num +
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(78); # N
  $rc .= chr(117); # u
  $rc .= chr(109); # m
  $rc .= chr(32); #  
  $rc .= chr(43); # +

  return $rc;
}
',
          '\\E[2p' => '
#
# Stub version of: \\E[2p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[?2h\\E[?3h\\E[?5h\\E[?7h\\E[?8h\\E>\\E[?1l\\E F\\E[?42l\\E[?4l' => '
#
# Stub version of: \\E[?2h\\E[?3h\\E[?5h\\E[?7h\\E[?8h\\E>\\E[?1l\\E F\\E[?42l\\E[?4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[1L$<5*>' => '
#
# Stub version of: \\E[1L$<5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\024T1\\016' => '
#
# Stub version of: \\024T1\\016
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(20); # \\024
  $rc .= chr(84); # T
  $rc .= chr(49); # 1
  $rc .= chr(14); # \\016

  return $rc;
}
',
          '\\E[2t\\E[4m' => '
#
# Stub version of: \\E[2t\\E[4m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(116); # t
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\377\\330' => '
#
# Stub version of: \\377\\330
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(216); # \\330

  return $rc;
}
',
          '\\Ey4\\Em70' => '
#
# Stub version of: \\Ey4\\Em70
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0

  return $rc;
}
',
          '^O^U^]' => '
#
# Stub version of: ^O^U^]
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^O
  $rc .= chr(0); # ^U
  $rc .= chr(0); # ^]

  return $rc;
}
',
          '^W35^W06' => '
#
# Stub version of: ^W35^W06
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^W
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(0); # ^W
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E[0*w' => '
#
# Stub version of: \\E[0*w
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\036RG0%p1%02X%p2%{255}%*%{1000}%/%02X%p3%{255}%*%{1000}%/%02X%p4%{255}%*%{1000}%/%02X%p5%{255}%*%{1000}%/%02X%p6%{255}%*%{1000}%/%02X%p7%{255}%*%{1000}%/%02X' => '
#
# Stub version of: \\036RG0%p1%02X%p2%{255}%*%{1000}%/%02X%p3%{255}%*%{1000}%/%02X%p4%{255}%*%{1000}%/%02X%p5%{255}%*%{1000}%/%02X%p6%{255}%*%{1000}%/%02X%p7%{255}%*%{1000}%/%02X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%02X\', pop(@iparam)); # %02X
  push(@iparam, $param[1]); # %p2
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= sprintf(\'%02X\', pop(@iparam)); # %02X
  push(@iparam, $param[2]); # %p3
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= sprintf(\'%02X\', pop(@iparam)); # %02X
  push(@iparam, $param[3]); # %p4
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= sprintf(\'%02X\', pop(@iparam)); # %02X
  push(@iparam, $param[4]); # %p5
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= sprintf(\'%02X\', pop(@iparam)); # %02X
  push(@iparam, $param[5]); # %p6
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= sprintf(\'%02X\', pop(@iparam)); # %02X
  push(@iparam, $param[6]); # %p7
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= sprintf(\'%02X\', pop(@iparam)); # %02X

  return $rc;
}
',
          '\\233D' => '
#
# Stub version of: \\233D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(68); # D

  return $rc;
}
',
          '%?%p9%t\\E(0%e\\E(B%;\\E[0%?%p6%t;1;43%;%?%p2%t;4;42%;%?%p1%t;7;31%;%?%p3%t;7;34%;%?%p4%t;5%;%?%p7%t;8%;m' => '
#
# Stub version of: %?%p9%t\\E(0%e\\E(B%;\\E[0%?%p6%t;1;43%;%?%p2%t;4;42%;%?%p1%t;7;31%;%?%p3%t;7;34%;%?%p4%t;5%;%?%p7%t;8%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
    $rc .= chr(51); # 3
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
    $rc .= chr(51); # 3
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
    $rc .= chr(51); # 3
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Eg1' => '
#
# Stub version of: \\Eg1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[7;34m' => '
#
# Stub version of: \\E[7;34m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E!^I' => '
#
# Stub version of: \\E!^I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(0); # ^I

  return $rc;
}
',
          '\\E[>5g\\E[?7h\\E[?5h' => '
#
# Stub version of: \\E[>5g\\E[?7h\\E[?5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\Ea%i%p1%dR%p2%dC' => '
#
# Stub version of: \\Ea%i%p1%dR%p2%dC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(97); # a
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(82); # R
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[25;2~' => '
#
# Stub version of: \\E[25;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E#=' => '
#
# Stub version of: \\E#=
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(61); # =

  return $rc;
}
',
          '\\EH\\EJ$<40>' => '
#
# Stub version of: \\EH\\EJ$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?5i\\E[5i' => '
#
# Stub version of: \\E[?5i\\E[5i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(105); # i
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\Ez_' => '
#
# Stub version of: \\Ez_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(95); # _

  return $rc;
}
',
          '\\E[H\\E[0J' => '
#
# Stub version of: \\E[H\\E[0J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[1;7x\\E[2;0x' => '
#
# Stub version of: \\E[1;7x\\E[2;0x
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(120); # x
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\E/>1h\\E/>9l' => '
#
# Stub version of: \\E/>1h\\E/>9l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(57); # 9
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\ENj' => '
#
# Stub version of: \\ENj
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(106); # j

  return $rc;
}
',
          '\\E[1;5S' => '
#
# Stub version of: \\E[1;5S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\377\\207' => '
#
# Stub version of: \\377\\207
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(135); # \\207

  return $rc;
}
',
          '\\EF11' => '
#
# Stub version of: \\EF11
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E!^B' => '
#
# Stub version of: \\E!^B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(0); # ^B

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%df' => '
#
# Stub version of: \\E[%i%p1%d;%p2%df
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\E\\003\\E4' => '
#
# Stub version of: \\E\\003\\E4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\E[%p1%dL$<36>' => '
#
# Stub version of: \\E[%p1%dL$<36>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EV\\r' => '
#
# Stub version of: \\EV\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[9' => '
#
# Stub version of: \\E[9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\233B\\r' => '
#
# Stub version of: \\233B\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(66); # B
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EFa' => '
#
# Stub version of: \\EFa
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\E7\\E[24;%p1%dH\\E[1K' => '
#
# Stub version of: \\E7\\E[24;%p1%dH\\E[1K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\r\\E[4i' => '
#
# Stub version of: \\r\\E[4i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E[<0;<1;<4l' => '
#
# Stub version of: \\E[<0;<1;<4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[04s' => '
#
# Stub version of: \\E[04s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E7\\E[r\\E8\\EE\\EE\\EE\\EM\\EM\\EM\\E[?7h\\E[?1l\\E[?3l\\E7\\E[1;29r\\E8' => '
#
# Stub version of: \\E7\\E[r\\E8\\EE\\EE\\EE\\EM\\EM\\EM\\E[?7h\\E[?1l\\E[?3l\\E7\\E[1;29r\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\Ec\\E[?3;5l\\E[56;0|' => '
#
# Stub version of: \\Ec\\E[?3;5l\\E[56;0|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\ES\\Er0;\\Es0;' => '
#
# Stub version of: \\ES\\Er0;\\Es0;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\ESTART\\r\\E2\\,0\\r\\E12\\r\\EEND\\r$<10>' => '
#
# Stub version of: \\ESTART\\r\\E2\\,0\\r\\E12\\r\\EEND\\r$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(84); # T
  $rc .= chr(65); # A
  $rc .= chr(82); # R
  $rc .= chr(84); # T
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(78); # N
  $rc .= chr(68); # D
  $rc .= chr(13); # \\r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\014$<4/>' => '
#
# Stub version of: \\E\\014$<4/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&' => '
#
# Stub version of: \\E&
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &

  return $rc;
}
',
          '\\EFr' => '
#
# Stub version of: \\EFr
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\Ef4' => '
#
# Stub version of: \\Ef4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\E!S' => '
#
# Stub version of: \\E!S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\377\\214' => '
#
# Stub version of: \\377\\214
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(140); # \\214

  return $rc;
}
',
          '\\EL$<5.5*>' => '
#
# Stub version of: \\EL$<5.5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1L$<9/>' => '
#
# Stub version of: \\E[1L$<9/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(57); # 9
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[L\\E[t' => '
#
# Stub version of: \\E[L\\E[t
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(76); # L
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\EA\\EJ\\EH\\E[L$<10>' => '
#
# Stub version of: \\EA\\EJ\\EH\\E[L$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dx' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dx
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\E[021q' => '
#
# Stub version of: \\E[021q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(113); # q

  return $rc;
}
',
          '^V<' => '
#
# Stub version of: ^V<
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(60); # <

  return $rc;
}
',
          '\\036FB%?%p1%t%p1%2.2X0%;%p2%p1%-%{1}%+%2.2X0%?%{24}%p2%>%t000%;\\036FX%p3%2.2X%p4%2.2X' => '
#
# Stub version of: \\036FB%?%p1%t%p1%2.2X0%;%p2%p1%-%{1}%+%2.2X0%?%{24}%p2%>%t000%;\\036FX%p3%2.2X%p4%2.2X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(66); # B
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
    $rc .= chr(48); # 0
  } # %;
  push(@iparam, $param[1]); # %p2
  push(@iparam, $param[0]); # %p1
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  push(@iparam, 1); # %{1}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, 24); # %{24}
           push(@iparam, $param[1]); # %p2
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
    $rc .= chr(48); # 0
    $rc .= chr(48); # 0
  } # %;
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(88); # X
  push(@iparam, $param[2]); # %p3
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  push(@iparam, $param[3]); # %p4
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X

  return $rc;
}
',
          '\\233005z' => '
#
# Stub version of: \\233005z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[>1;7B' => '
#
# Stub version of: \\E[>1;7B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[%p1%d;%p2%l%02dq   F%p1%1d           %p2%s' => '
#
# Stub version of: \\E[%p1%d;%p2%l%02dq   F%p1%1d           %p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%02d\', pop(@iparam)); # %02d
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%1d\', pop(@iparam)); # %1d
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\E0n' => '
#
# Stub version of: \\E0n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\E[140q' => '
#
# Stub version of: \\E[140q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[50;4|\\E[53;0|\\E[8;0|\\E[?4;13;15l\\E[13;20l\\E[?7h\\E[12h\\E(B\\E)0\\E[?31l\\E[0m\\017' => '
#
# Stub version of: \\E[50;4|\\E[53;0|\\E[8;0|\\E[?4;13;15l\\E[13;20l\\E[?7h\\E[12h\\E(B\\E)0\\E[?31l\\E[0m\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\037era;' => '
#
# Stub version of: \\037era;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(101); # e
  $rc .= chr(114); # r
  $rc .= chr(97); # a
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\EFv' => '
#
# Stub version of: \\EFv
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\E1n' => '
#
# Stub version of: \\E1n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\233013z' => '
#
# Stub version of: \\233013z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '^B?\\r' => '
#
# Stub version of: ^B?\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(63); # ?
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\014$<1000>' => '
#
# Stub version of: \\014$<1000>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[3g$<40>' => '
#
# Stub version of: \\E[3g$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(103); # g
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ezz&\\E[A\\177\\Ezz\'\\E[B\\177\\Ezz(\\E[D\\177\\Ezz)\\E[C\\177\\Ezz<\\E[Q\\177' => '
#
# Stub version of: \\Ezz&\\E[A\\177\\Ezz\'\\E[B\\177\\Ezz(\\E[D\\177\\Ezz)\\E[C\\177\\Ezz<\\E[Q\\177
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(38); # &
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(66); # B
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(68); # D
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(41); # )
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(67); # C
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(81); # Q
  $rc .= chr(127); # \\177

  return $rc;
}
',
          '\\EJ' => '
#
# Stub version of: \\EJ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[x' => '
#
# Stub version of: \\E[x
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\E\\003\\E0' => '
#
# Stub version of: \\E\\003\\E0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E.2' => '
#
# Stub version of: \\E.2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(50); # 2

  return $rc;
}
',
          'jDkClBmAnIqKtMuLvOwNxJ' => '
#
# Stub version of: jDkClBmAnIqKtMuLvOwNxJ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(106); # j
  $rc .= chr(68); # D
  $rc .= chr(107); # k
  $rc .= chr(67); # C
  $rc .= chr(108); # l
  $rc .= chr(66); # B
  $rc .= chr(109); # m
  $rc .= chr(65); # A
  $rc .= chr(110); # n
  $rc .= chr(73); # I
  $rc .= chr(113); # q
  $rc .= chr(75); # K
  $rc .= chr(116); # t
  $rc .= chr(77); # M
  $rc .= chr(117); # u
  $rc .= chr(76); # L
  $rc .= chr(118); # v
  $rc .= chr(79); # O
  $rc .= chr(119); # w
  $rc .= chr(78); # N
  $rc .= chr(120); # x
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\EY$<20>' => '
#
# Stub version of: \\EY$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\2335i' => '
#
# Stub version of: \\2335i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(53); # 5
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E[20;2~' => '
#
# Stub version of: \\E[20;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^^-' => '
#
# Stub version of: ^^-
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(45); # -

  return $rc;
}
',
          '\\E[?2h\\E[?3l\\E[?5l\\E[?7h\\E[?8h\\E>\\E[?1l\\E G\\E[?42l\\E[?4l' => '
#
# Stub version of: \\E[?2h\\E[?3l\\E[?5l\\E[?7h\\E[?8h\\E>\\E[?1l\\E G\\E[?42l\\E[?4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E\\001\\E1' => '
#
# Stub version of: \\E\\001\\E1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[?5l\\E[47h\\E[40l\\E[r' => '
#
# Stub version of: \\E[?5l\\E[47h\\E[40l\\E[r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\EP2~' => '
#
# Stub version of: \\EP2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^CB' => '
#
# Stub version of: ^CB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^C
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[7;6~' => '
#
# Stub version of: \\E[7;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '%?%p8%t\\E)%e\\E(%;%?%p9%t\\EcE%e\\EcD%;\\EG%{48}%?%p2%t%{8}%|%;%?%p1%p3%|%p6%|%t%{4}%|%;%?%p4%t%{2}%|%;%?%p1%p5%|%t%{64}%|%;%?%p7%t%{1}%|%;%c' => '
#
# Stub version of: %?%p8%t\\E)%e\\E(%;%?%p9%t\\EcE%e\\EcD%;\\EG%{48}%?%p2%t%{8}%|%;%?%p1%p3%|%p6%|%t%{4}%|%;%?%p4%t%{2}%|%;%?%p1%p5%|%t%{64}%|%;%?%p7%t%{1}%|%;%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[7]); # %p8
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(41); # )
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(99); # c
    $rc .= chr(69); # E
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(99); # c
    $rc .= chr(68); # D
  } # %;
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  push(@iparam, 48); # %{48}
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    push(@iparam, 8); # %{8}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 64); # %{64}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\2330%?%p6%t;1%;%?%p2%t;4%;%?%p4%t;5%;%?%p1%p3%|%t;7%;m%?%p9%t\\E(0%e\\E(B%;$<2>' => '
#
# Stub version of: \\2330%?%p6%t;1%;%?%p2%t;4%;%?%p4%t;5%;%?%p1%p3%|%t;7%;m%?%p9%t\\E(0%e\\E(B%;$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&p13C' => '
#
# Stub version of: \\E&p13C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(112); # p
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(67); # C

  return $rc;
}
',
          '^V^F' => '
#
# Stub version of: ^V^F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^F

  return $rc;
}
',
          '\\E[2;0#w\\E[1;25r' => '
#
# Stub version of: \\E[2;0#w\\E[1;25r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(35); # #
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\Ev\\Ee\\Ez_' => '
#
# Stub version of: \\Ev\\Ee\\Ez_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(95); # _

  return $rc;
}
',
          '\\E?p' => '
#
# Stub version of: \\E?p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(112); # p

  return $rc;
}
',
          '^M^Z' => '
#
# Stub version of: ^M^Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^M
  $rc .= chr(0); # ^Z

  return $rc;
}
',
          '^C' => '
#
# Stub version of: ^C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^C

  return $rc;
}
',
          '\\E6\\s' => '
#
# Stub version of: \\E6\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(54); # 6
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\0Z' => '
#
# Stub version of: \\0Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(90); # Z

  return $rc;
}
',
          '^AJ\\r' => '
#
# Stub version of: ^AJ\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(74); # J
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EKA0\\ELV0\\EMG0' => '
#
# Stub version of: \\EKA0\\ELV0\\EMG0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(65); # A
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(86); # V
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(71); # G
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\036B%p1%?%p1%{8}%<%t%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%;%{48}%+%c' => '
#
# Stub version of: \\036B%p1%?%p1%{8}%<%t%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%;%{48}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(66); # B
  push(@iparam, $param[0]); # %p1
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 8); # %{8}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
    push(@iparam, pop(@iparam) & pop(@iparam)); # %&
    if (do { # %?
             push(@iparam, $param[0]); # %p1
             push(@iparam, 1); # %{1}
             push(@iparam, pop(@iparam) & pop(@iparam)); # %&
             pop(@iparam);
           }) { # %t
      push(@iparam, 4); # %{4}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
    if (do { # %?
             push(@iparam, $param[0]); # %p1
             push(@iparam, 4); # %{4}
             push(@iparam, pop(@iparam) & pop(@iparam)); # %&
             pop(@iparam);
           }) { # %t
      push(@iparam, 1); # %{1}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
  } # %;
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '^\\040\\r' => '
#
# Stub version of: ^\\040\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(32); # \\040
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EY$<8*>' => '
#
# Stub version of: \\EY$<8*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '^NV' => '
#
# Stub version of: ^NV
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^N
  $rc .= chr(86); # V

  return $rc;
}
',
          '\\377\\343' => '
#
# Stub version of: \\377\\343
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(227); # \\343

  return $rc;
}
',
          '^AO\\r' => '
#
# Stub version of: ^AO\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(79); # O
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E%!1\\E[?6l\\E[2J' => '
#
# Stub version of: \\E%!1\\E[?6l\\E[2J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\EI$<10*>' => '
#
# Stub version of: \\EI$<10*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '^V+' => '
#
# Stub version of: ^V+
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(43); # +

  return $rc;
}
',
          '\\E[<p' => '
#
# Stub version of: \\E[<p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E(B\\E[2l\\E>\\E[20l\\E[?3l\\E[?5h\\E[?7h\\E[1;24r\\E[24;1H\\E[H\\E[J' => '
#
# Stub version of: \\E(B\\E[2l\\E>\\E[20l\\E[?3l\\E[?5h\\E[?7h\\E[1;24r\\E[24;1H\\E[H\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '^V^D' => '
#
# Stub version of: ^V^D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^D

  return $rc;
}
',
          '^\\004\\r' => '
#
# Stub version of: ^\\004\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(4); # \\004
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[H\\E[J$<156>\\E[33p\\E[255;1H\\E[K' => '
#
# Stub version of: \\E[H\\E[J$<156>\\E[33p\\E[255;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\EM"' => '
#
# Stub version of: \\EM"
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(34); # "

  return $rc;
}
',
          '\\EO1;2S' => '
#
# Stub version of: \\EO1;2S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E#6' => '
#
# Stub version of: \\E#6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E[001q' => '
#
# Stub version of: \\E[001q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[105z' => '
#
# Stub version of: \\E[105z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(122); # z

  return $rc;
}
',
          '^^\\:' => '
#
# Stub version of: ^^\\:
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(128); # \\:

  return $rc;
}
',
          '\\E[5;37;41m' => '
#
# Stub version of: \\E[5;37;41m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E%!1\\E[2;32r\\E[132D\\E[2g\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[J' => '
#
# Stub version of: \\E%!1\\E[2;32r\\E[132D\\E[2g\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(68); # D
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\ECI' => '
#
# Stub version of: \\ECI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\EE\\EF \\011' => '
#
# Stub version of: \\EE\\EF \\011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(32); #  
  $rc .= chr(9); # \\011

  return $rc;
}
',
          '\\Eh\\ER' => '
#
# Stub version of: \\Eh\\ER
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\Ec\\E[12;31h\\E[?4;5;10l\\E?3;6;7;19;25h\\E[33;34l\\E[0m\\E(B\\E)0\\E%/0n\\E[P\\031$<200>' => '
#
# Stub version of: \\Ec\\E[12;31h\\E[?4;5;10l\\E?3;6;7;19;25h\\E[33;34l\\E[0m\\E(B\\E)0\\E%/0n\\E[P\\031$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $rc .= chr(48); # 0
  $rc .= chr(110); # n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(80); # P
  $rc .= chr(25); # \\031
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[>7h\\E[>9l' => '
#
# Stub version of: \\E[>7h\\E[>9l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(57); # 9
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EF3' => '
#
# Stub version of: \\EF3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\EOH' => '
#
# Stub version of: \\EOH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(72); # H

  return $rc;
}
',
          '%?%p1%{0}%=%t\\E(B%e%p1%{1}%=%t\\E(A%e%p1%{2}%=%t\\E(C%e%p1%{3}%=%t\\E(D%e%p1%{4}%=%t\\E(E%e%p1%{5}%=%t\\E(H%e%p1%{6}%=%t\\E(K%e%p1%{7}%=%t\\E(R%e%p1%{8}%=%t\\E(Q%e%p1%{9}%=%t\\E(Y%e%p1%{10}%=%t\\E(Z%e%p1%{11}%=%t\\E(0%e%p1%{12}%=%t\\E(1%e%p1%{13}%=%t\\E(3%e%p1%{14}%=%t\\E(8%e%p1%{15}%=%t\\E(}%;' => '
#
# Stub version of: %?%p1%{0}%=%t\\E(B%e%p1%{1}%=%t\\E(A%e%p1%{2}%=%t\\E(C%e%p1%{3}%=%t\\E(D%e%p1%{4}%=%t\\E(E%e%p1%{5}%=%t\\E(H%e%p1%{6}%=%t\\E(K%e%p1%{7}%=%t\\E(R%e%p1%{8}%=%t\\E(Q%e%p1%{9}%=%t\\E(Y%e%p1%{10}%=%t\\E(Z%e%p1%{11}%=%t\\E(0%e%p1%{12}%=%t\\E(1%e%p1%{13}%=%t\\E(3%e%p1%{14}%=%t\\E(8%e%p1%{15}%=%t\\E(}%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 1); # %{1}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(65); # A
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 2); # %{2}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(67); # C
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(68); # D
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(69); # E
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 5); # %{5}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(72); # H
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(75); # K
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 7); # %{7}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(82); # R
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 8); # %{8}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(81); # Q
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 9); # %{9}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(89); # Y
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 10); # %{10}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(90); # Z
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 11); # %{11}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 12); # %{12}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 13); # %{13}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(51); # 3
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 14); # %{14}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(56); # 8
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 15); # %{15}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(125); # }
  }

  return $rc;
}
',
          '^Z2' => '
#
# Stub version of: ^Z2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Z
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\016@\\026$<145>' => '
#
# Stub version of: \\016@\\026$<145>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  $rc .= chr(64); # @
  $rc .= chr(22); # \\026
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\371' => '
#
# Stub version of: \\377\\371
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(249); # \\371

  return $rc;
}
',
          '\\E[C$<2/>' => '
#
# Stub version of: \\E[C$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E!l\\r' => '
#
# Stub version of: \\E!l\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(108); # l
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[m\\E[2;24r' => '
#
# Stub version of: \\E[m\\E[2;24r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[112z' => '
#
# Stub version of: \\E[112z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EyA' => '
#
# Stub version of: \\EyA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[0;98v\\E[2J\\E[v' => '
#
# Stub version of: \\E[0;98v\\E[2J\\E[v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\E[%p1%dB' => '
#
# Stub version of: \\E[%p1%dB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\2330M' => '
#
# Stub version of: \\2330M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\217E' => '
#
# Stub version of: \\217E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\E|%p1%{48}%+%c2%p2%s\\031' => '
#
# Stub version of: \\E|%p1%{48}%+%c2%p2%s\\031
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(124); # |
  push(@iparam, $param[0]); # %p1
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(50); # 2
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(25); # \\031

  return $rc;
}
',
          '\\E[014q' => '
#
# Stub version of: \\E[014q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[3;0v' => '
#
# Stub version of: \\E[3;0v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(118); # v

  return $rc;
}
',
          'j*k(l m"q&v%w#x-' => '
#
# Stub version of: j*k(l m"q&v%w#x-
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(106); # j
  $rc .= chr(42); # *
  $rc .= chr(107); # k
  $rc .= chr(40); # (
  $rc .= chr(108); # l
  $rc .= chr(32); #  
  $rc .= chr(109); # m
  $rc .= chr(34); # "
  $rc .= chr(113); # q
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(37); # %
  $rc .= chr(119); # w
  $rc .= chr(35); # #
  $rc .= chr(120); # x
  $rc .= chr(45); # -

  return $rc;
}
',
          '\\E[%p1%dM' => '
#
# Stub version of: \\E[%p1%dM
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\EFZ' => '
#
# Stub version of: \\EFZ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\233004z' => '
#
# Stub version of: \\233004z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[26~' => '
#
# Stub version of: \\E[26~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EO1;6S' => '
#
# Stub version of: \\EO1;6S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\EP`>z~[[J`8xz~[[A`4xz~[[D`6xz~[[C`2xz~[[B\\E\\\\' => '
#
# Stub version of: \\EP`>z~[[J`8xz~[[A`4xz~[[D`6xz~[[C`2xz~[[B\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(96); # `
  $rc .= chr(62); # >
  $rc .= chr(122); # z
  $rc .= chr(126); # ~
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(96); # `
  $rc .= chr(56); # 8
  $rc .= chr(120); # x
  $rc .= chr(122); # z
  $rc .= chr(126); # ~
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(96); # `
  $rc .= chr(52); # 4
  $rc .= chr(120); # x
  $rc .= chr(122); # z
  $rc .= chr(126); # ~
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(68); # D
  $rc .= chr(96); # `
  $rc .= chr(54); # 6
  $rc .= chr(120); # x
  $rc .= chr(122); # z
  $rc .= chr(126); # ~
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(67); # C
  $rc .= chr(96); # `
  $rc .= chr(50); # 2
  $rc .= chr(120); # x
  $rc .= chr(122); # z
  $rc .= chr(126); # ~
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E[<12h\\E[<14h' => '
#
# Stub version of: \\E[<12h\\E[<14h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E{' => '
#
# Stub version of: \\E{
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(123); # {

  return $rc;
}
',
          '\\Ef' => '
#
# Stub version of: \\Ef
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\Er%p1%c%p2%{32}%+%c$<.2*>' => '
#
# Stub version of: \\Er%p1%c%p2%{32}%+%c$<.2*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(46); # .
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO\\Eq\\EG\\Ew\\EJ\\EY7 K4 MS Kermit 2.27 for the IBMPC 3-17-85\\n' => '
#
# Stub version of: \\EO\\Eq\\EG\\Ew\\EJ\\EY7 K4 MS Kermit 2.27 for the IBMPC 3-17-85\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(75); # K
  $rc .= chr(52); # 4
  $rc .= chr(32); #  
  $rc .= chr(77); # M
  $rc .= chr(83); # S
  $rc .= chr(32); #  
  $rc .= chr(75); # K
  $rc .= chr(101); # e
  $rc .= chr(114); # r
  $rc .= chr(109); # m
  $rc .= chr(105); # i
  $rc .= chr(116); # t
  $rc .= chr(32); #  
  $rc .= chr(50); # 2
  $rc .= chr(46); # .
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(111); # o
  $rc .= chr(114); # r
  $rc .= chr(32); #  
  $rc .= chr(116); # t
  $rc .= chr(104); # h
  $rc .= chr(101); # e
  $rc .= chr(32); #  
  $rc .= chr(73); # I
  $rc .= chr(66); # B
  $rc .= chr(77); # M
  $rc .= chr(80); # P
  $rc .= chr(67); # C
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(45); # -
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(45); # -
  $rc .= chr(56); # 8
  $rc .= chr(53); # 5
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\EFH' => '
#
# Stub version of: \\EFH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(72); # H

  return $rc;
}
',
          '%?%p1%p2%|%p3%|%p6%|%p7%|%t\\026\\001%?%p7%t%{128}%e%{0}%?%p1%t%{112}%|%;%?%p2%t%{1}%|%;%?%p3%t%{112}%|%;%?%p6%t%{16}%|%;%;%c%;%?%p4%t\\026\\002%;' => '
#
# Stub version of: %?%p1%p2%|%p3%|%p6%|%p7%|%t\\026\\001%?%p7%t%{128}%e%{0}%?%p1%t%{112}%|%;%?%p2%t%{1}%|%;%?%p3%t%{112}%|%;%?%p6%t%{16}%|%;%;%c%;%?%p4%t\\026\\002%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[1]); # %p2
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[6]); # %p7
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(22); # \\026
    $rc .= chr(1); # \\001
    if (do { # %?
             push(@iparam, $param[6]); # %p7
             pop(@iparam);
           }) { # %t
      push(@iparam, 128); # %{128}
    }
    else { # %e
      push(@iparam, 0); # %{0}
      if (do { # %?
               push(@iparam, $param[0]); # %p1
               pop(@iparam);
             }) { # %t
        push(@iparam, 112); # %{112}
        push(@iparam, pop(@iparam) | pop(@iparam)); # %|
      } # %;
      if (do { # %?
               push(@iparam, $param[1]); # %p2
               pop(@iparam);
             }) { # %t
        push(@iparam, 1); # %{1}
        push(@iparam, pop(@iparam) | pop(@iparam)); # %|
      } # %;
      if (do { # %?
               push(@iparam, $param[2]); # %p3
               pop(@iparam);
             }) { # %t
        push(@iparam, 112); # %{112}
        push(@iparam, pop(@iparam) | pop(@iparam)); # %|
      } # %;
      if (do { # %?
               push(@iparam, $param[5]); # %p6
               pop(@iparam);
             }) { # %t
        push(@iparam, 16); # %{16}
        push(@iparam, pop(@iparam) | pop(@iparam)); # %|
      } # %;
    } # %;
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(22); # \\026
    $rc .= chr(2); # \\002
  } # %;

  return $rc;
}
',
          '^VJ\\r' => '
#
# Stub version of: ^VJ\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(74); # J
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[110z' => '
#
# Stub version of: \\E[110z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\014$<2>' => '
#
# Stub version of: \\014$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          'pf4' => '
#
# Stub version of: pf4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(112); # p
  $rc .= chr(102); # f
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\E[492Z' => '
#
# Stub version of: \\E[492Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(50); # 2
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\E[>1l' => '
#
# Stub version of: \\E[>1l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[007z' => '
#
# Stub version of: \\E[007z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(122); # z

  return $rc;
}
',
          '%?%p1%{10}%=%t\\E[w%e%p1%{12}%=%t\\E[2w%e%p1%{5}%=%t\\E[5w%e%p1%{13}%=%p1%{14}%=%O%t\\E[3w%e%p1%{16}%=%p1%{17}%=%O%t\\E[4w%e%p1%{6}%=%t\\E[6w%e%p1%{7}%=%t\\E[7w%e%p1%{8}%=%t\\E[8w%;' => '
#
# Stub version of: %?%p1%{10}%=%t\\E[w%e%p1%{12}%=%t\\E[2w%e%p1%{5}%=%t\\E[5w%e%p1%{13}%=%p1%{14}%=%O%t\\E[3w%e%p1%{16}%=%p1%{17}%=%O%t\\E[4w%e%p1%{6}%=%t\\E[6w%e%p1%{7}%=%t\\E[7w%e%p1%{8}%=%t\\E[8w%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 10); # %{10}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(119); # w
  } # %;
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 12); # %{12}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(50); # 2
    $rc .= chr(119); # w
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 5); # %{5}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(53); # 5
    $rc .= chr(119); # w
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 13); # %{13}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              push(@iparam, $param[0]); # %p1
              push(@iparam, 14); # %{14}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              push(@iparam, pop(@iparam) || pop(@iparam)); # %O
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(51); # 3
    $rc .= chr(119); # w
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 16); # %{16}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              push(@iparam, $param[0]); # %p1
              push(@iparam, 17); # %{17}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              push(@iparam, pop(@iparam) || pop(@iparam)); # %O
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(52); # 4
    $rc .= chr(119); # w
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(54); # 6
    $rc .= chr(119); # w
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 7); # %{7}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(55); # 7
    $rc .= chr(119); # w
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 8); # %{8}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(56); # 8
    $rc .= chr(119); # w
  }

  return $rc;
}
',
          '^]^_' => '
#
# Stub version of: ^]^_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^]
  $rc .= chr(0); # ^_

  return $rc;
}
',
          '\\E[216z' => '
#
# Stub version of: \\E[216z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[3;7~' => '
#
# Stub version of: \\E[3;7~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^Od' => '
#
# Stub version of: ^Od
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^O
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\017$<1>' => '
#
# Stub version of: \\017$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\011%i%p1%c' => '
#
# Stub version of: \\E\\011%i%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(9); # \\011
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[P$<30>' => '
#
# Stub version of: \\E[P$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EOA' => '
#
# Stub version of: \\EOA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(65); # A

  return $rc;
}
',
          '$<0.4*>' => '
#
# Stub version of: $<0.4*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(48); # 0
  $rc .= chr(46); # .
  $rc .= chr(52); # 4
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EAAF' => '
#
# Stub version of: \\EAAF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(65); # A
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\037wor 0' => '
#
# Stub version of: \\037wor 0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(119); # w
  $rc .= chr(111); # o
  $rc .= chr(114); # r
  $rc .= chr(32); #  
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\EO\\Eq\\EJ\\EY7 K3 UCB IBMPC Kermit 1.20  12-19-84\\n' => '
#
# Stub version of: \\EO\\Eq\\EJ\\EY7 K3 UCB IBMPC Kermit 1.20  12-19-84\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(75); # K
  $rc .= chr(51); # 3
  $rc .= chr(32); #  
  $rc .= chr(85); # U
  $rc .= chr(67); # C
  $rc .= chr(66); # B
  $rc .= chr(32); #  
  $rc .= chr(73); # I
  $rc .= chr(66); # B
  $rc .= chr(77); # M
  $rc .= chr(80); # P
  $rc .= chr(67); # C
  $rc .= chr(32); #  
  $rc .= chr(75); # K
  $rc .= chr(101); # e
  $rc .= chr(114); # r
  $rc .= chr(109); # m
  $rc .= chr(105); # i
  $rc .= chr(116); # t
  $rc .= chr(32); #  
  $rc .= chr(49); # 1
  $rc .= chr(46); # .
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(45); # -
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(45); # -
  $rc .= chr(56); # 8
  $rc .= chr(52); # 4
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '^\\036\\r' => '
#
# Stub version of: ^\\036\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(30); # \\036
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\377\\212' => '
#
# Stub version of: \\377\\212
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(138); # \\212

  return $rc;
}
',
          '\\E[8;0|\\E[?3;4;5;13;15l\\E[13;20l\\E[?7h\\E[12h' => '
#
# Stub version of: \\E[8;0|\\E[?3;4;5;13;15l\\E[13;20l\\E[?7h\\E[12h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E7F2' => '
#
# Stub version of: \\E7F2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(70); # F
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E[_' => '
#
# Stub version of: \\E[_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(95); # _

  return $rc;
}
',
          '\\E[13l\\E[3l\\E!p' => '
#
# Stub version of: \\E[13l\\E[3l\\E!p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E&f1a%p1%dk0d%p2%l%dL%p2%s' => '
#
# Stub version of: \\E&f1a%p1%dk0d%p2%l%dL%p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(102); # f
  $rc .= chr(49); # 1
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(107); # k
  $rc .= chr(48); # 0
  $rc .= chr(100); # d
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\014$<5>' => '
#
# Stub version of: \\014$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[4%p1%{8}%m%d%?%p1%{7}%>%t;5%e;25%;m' => '
#
# Stub version of: \\E[4%p1%{8}%m%d%?%p1%{7}%>%t;5%e;25%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  push(@iparam, $param[0]); # %p1
  push(@iparam, 8); # %{8}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 7); # %{7}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  }
  else { # %e
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
    $rc .= chr(53); # 5
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Ew\\Eq\\Ez\\EB' => '
#
# Stub version of: \\Ew\\Eq\\Ez\\EB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(27); # \\E
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E$B' => '
#
# Stub version of: \\E$B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\036E$<\\0/>' => '
#
# Stub version of: \\036E$<\\0/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(128); # \\0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[2;25w\\E2\\r' => '
#
# Stub version of: \\E[2;25w\\E2\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^B<\\r' => '
#
# Stub version of: ^B<\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(60); # <
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%p1%dM$<1*>' => '
#
# Stub version of: \\E[%p1%dM$<1*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&a+%p1%dR' => '
#
# Stub version of: \\E&a+%p1%dR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  $rc .= chr(43); # +
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E%p1%dA$<5>' => '
#
# Stub version of: \\E%p1%dA$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(65); # A
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EF\\014 kf64=\\EF$' => '
#
# Stub version of: \\EF\\014 kf64=\\EF$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(12); # \\014
  $rc .= chr(32); #  
  $rc .= chr(107); # k
  $rc .= chr(102); # f
  $rc .= chr(54); # 6
  $rc .= chr(52); # 4
  $rc .= chr(61); # =
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\0i' => '
#
# Stub version of: \\0i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E\\\\1\\E-07\\s' => '
#
# Stub version of: \\E\\\\1\\E-07\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(45); # -
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '^\\I`' => '
#
# Stub version of: ^\\I`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(92); # \\
  $rc .= chr(73); # I
  $rc .= chr(96); # `

  return $rc;
}
',
          '\\E^F' => '
#
# Stub version of: \\E^F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^F

  return $rc;
}
',
          '\\E[%p1%dP$<3*>' => '
#
# Stub version of: \\E[%p1%dP$<3*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\366' => '
#
# Stub version of: \\377\\366
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(246); # \\366

  return $rc;
}
',
          '\\E[?1l\\E>' => '
#
# Stub version of: \\E[?1l\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '+h.kaiggjdkclfmenbozqas{tvutvuwsx`~\\^' => '
#
# Stub version of: +h.kaiggjdkclfmenbozqas{tvutvuwsx`~\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(104); # h
  $rc .= chr(46); # .
  $rc .= chr(107); # k
  $rc .= chr(97); # a
  $rc .= chr(105); # i
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(106); # j
  $rc .= chr(100); # d
  $rc .= chr(107); # k
  $rc .= chr(99); # c
  $rc .= chr(108); # l
  $rc .= chr(102); # f
  $rc .= chr(109); # m
  $rc .= chr(101); # e
  $rc .= chr(110); # n
  $rc .= chr(98); # b
  $rc .= chr(111); # o
  $rc .= chr(122); # z
  $rc .= chr(113); # q
  $rc .= chr(97); # a
  $rc .= chr(115); # s
  $rc .= chr(123); # {
  $rc .= chr(116); # t
  $rc .= chr(118); # v
  $rc .= chr(117); # u
  $rc .= chr(116); # t
  $rc .= chr(118); # v
  $rc .= chr(117); # u
  $rc .= chr(119); # w
  $rc .= chr(115); # s
  $rc .= chr(120); # x
  $rc .= chr(96); # `
  $rc .= chr(126); # ~
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\E[?%p1%dT' => '
#
# Stub version of: \\E[?%p1%dT
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\ENq' => '
#
# Stub version of: \\ENq
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\EE%p1%{32}%+%c' => '
#
# Stub version of: \\EE%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[%p1%dB$<5>' => '
#
# Stub version of: \\E[%p1%dB$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(66); # B
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[L$<5>' => '
#
# Stub version of: \\E[L$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E]R' => '
#
# Stub version of: \\E]R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(82); # R

  return $rc;
}
',
          '^\\^X' => '
#
# Stub version of: ^\\^X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(128); # \\^
  $rc .= chr(88); # X

  return $rc;
}
',
          '\\E[1Q\\E[m\\E[>20l\\E[>30h' => '
#
# Stub version of: \\E[1Q\\E[m\\E[>20l\\E[>30h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\0\\206' => '
#
# Stub version of: \\0\\206
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(134); # \\206

  return $rc;
}
',
          '\\0M' => '
#
# Stub version of: \\0M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\23320l' => '
#
# Stub version of: \\23320l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E`;\\E`9$<30>' => '
#
# Stub version of: \\E`;\\E`9$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(59); # ;
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[=0;0m' => '
#
# Stub version of: \\E[=0;0m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Ei2' => '
#
# Stub version of: \\Ei2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(105); # i
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\0?' => '
#
# Stub version of: \\0?
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(63); # ?

  return $rc;
}
',
          '\\0D' => '
#
# Stub version of: \\0D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(68); # D

  return $rc;
}
',
          '^A1\\r' => '
#
# Stub version of: ^A1\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(49); # 1
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EcB2\\EcC3' => '
#
# Stub version of: \\EcB2\\EcC3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(66); # B
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(67); # C
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E?f' => '
#
# Stub version of: \\E?f
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\EP$<3>' => '
#
# Stub version of: \\EP$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '%?%p1%p2%|%p3%|%p4%|%p5%|%p7%|%t\\E0%{64}%?%p1%t%{17}%|%;%?%p2%t%{32}%|%;%?%p3%t%{16}%|%;%?%p4%t%{2}%|%;%?%p5%t%{1}%|%;%c%?%p7%tD%;\\E)%e\\E(%;' => '
#
# Stub version of: %?%p1%p2%|%p3%|%p4%|%p5%|%p7%|%t\\E0%{64}%?%p1%t%{17}%|%;%?%p2%t%{32}%|%;%?%p3%t%{16}%|%;%?%p4%t%{2}%|%;%?%p5%t%{1}%|%;%c%?%p7%tD%;\\E)%e\\E(%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[1]); # %p2
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[3]); # %p4
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[6]); # %p7
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(48); # 0
    push(@iparam, 64); # %{64}
    if (do { # %?
             push(@iparam, $param[0]); # %p1
             pop(@iparam);
           }) { # %t
      push(@iparam, 17); # %{17}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
    if (do { # %?
             push(@iparam, $param[1]); # %p2
             pop(@iparam);
           }) { # %t
      push(@iparam, 32); # %{32}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
    if (do { # %?
             push(@iparam, $param[2]); # %p3
             pop(@iparam);
           }) { # %t
      push(@iparam, 16); # %{16}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
    if (do { # %?
             push(@iparam, $param[3]); # %p4
             pop(@iparam);
           }) { # %t
      push(@iparam, 2); # %{2}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
    if (do { # %?
             push(@iparam, $param[4]); # %p5
             pop(@iparam);
           }) { # %t
      push(@iparam, 1); # %{1}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
    if (do { # %?
             push(@iparam, $param[6]); # %p7
             pop(@iparam);
           }) { # %t
      $rc .= chr(68); # D
    } # %;
    $rc .= chr(27); # \\E
    $rc .= chr(41); # )
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
  } # %;

  return $rc;
}
',
          '^^PD' => '
#
# Stub version of: ^^PD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[[E' => '
#
# Stub version of: \\E[[E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\23339;49m' => '
#
# Stub version of: \\23339;49m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(109); # m

  return $rc;
}
',
          '^B8\\r' => '
#
# Stub version of: ^B8\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(56); # 8
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\23327m' => '
#
# Stub version of: \\23327m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\2331$}\\2332$~' => '
#
# Stub version of: \\2331$}\\2332$~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(125); # }
  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[2B' => '
#
# Stub version of: \\E[2B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\EW$<1>' => '
#
# Stub version of: \\EW$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          'RIGHT' => '
#
# Stub version of: RIGHT
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(82); # R
  $rc .= chr(73); # I
  $rc .= chr(71); # G
  $rc .= chr(72); # H
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\E[?%[;0123456789]c' => '
#
# Stub version of: \\E[?%[;0123456789]c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(37); # %
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(55); # 7
  $rc .= chr(56); # 8
  $rc .= chr(57); # 9
  $rc .= chr(93); # ]
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\037$<2*/>' => '
#
# Stub version of: \\037$<2*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EC$<3>' => '
#
# Stub version of: \\EC$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\s' => '
#
# Stub version of: \\E\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\EP%p1%03d' => '
#
# Stub version of: \\EP%p1%03d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%03d\', pop(@iparam)); # %03d

  return $rc;
}
',
          '\\026\\010%p1%c%p2%c' => '
#
# Stub version of: \\026\\010%p1%c%p2%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(22); # \\026
  $rc .= chr(8); # \\010
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\377\\262' => '
#
# Stub version of: \\377\\262
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(178); # \\262

  return $rc;
}
',
          '\\E[6+{' => '
#
# Stub version of: \\E[6+{
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(43); # +
  $rc .= chr(123); # {

  return $rc;
}
',
          '\\E[m$<2>' => '
#
# Stub version of: \\E[m$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '00``aaffgghhjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~' => '
#
# Stub version of: 00``aaffgghhjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(104); # h
  $rc .= chr(104); # h
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(121); # y
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(123); # {
  $rc .= chr(123); # {
  $rc .= chr(124); # |
  $rc .= chr(124); # |
  $rc .= chr(125); # }
  $rc .= chr(125); # }
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[2;4~' => '
#
# Stub version of: \\E[2;4~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[25;1H' => '
#
# Stub version of: \\E[25;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '^H^\\' => '
#
# Stub version of: ^H^\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^H
  $rc .= chr(94); # ^
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\036F]\\036FT0' => '
#
# Stub version of: \\036F]\\036FT0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(93); # ]
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(84); # T
  $rc .= chr(48); # 0

  return $rc;
}
',
          '^^u' => '
#
# Stub version of: ^^u
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\E[39;49m' => '
#
# Stub version of: \\E[39;49m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(109); # m

  return $rc;
}
',
          '$<6*/>' => '
#
# Stub version of: $<6*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ec\\E[?3l' => '
#
# Stub version of: \\Ec\\E[?3l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[w\\E2\\r\\n' => '
#
# Stub version of: \\E[w\\E2\\r\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\E[008z' => '
#
# Stub version of: \\E[008z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(122); # z

  return $rc;
}
',
          'K0 Standard Kermit  9-25-84\\n' => '
#
# Stub version of: K0 Standard Kermit  9-25-84\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(75); # K
  $rc .= chr(48); # 0
  $rc .= chr(32); #  
  $rc .= chr(83); # S
  $rc .= chr(116); # t
  $rc .= chr(97); # a
  $rc .= chr(110); # n
  $rc .= chr(100); # d
  $rc .= chr(97); # a
  $rc .= chr(114); # r
  $rc .= chr(100); # d
  $rc .= chr(32); #  
  $rc .= chr(75); # K
  $rc .= chr(101); # e
  $rc .= chr(114); # r
  $rc .= chr(109); # m
  $rc .= chr(105); # i
  $rc .= chr(116); # t
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(57); # 9
  $rc .= chr(45); # -
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(45); # -
  $rc .= chr(56); # 8
  $rc .= chr(52); # 4
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\376X\\376C\\376R\\376K\\376T' => '
#
# Stub version of: \\376X\\376C\\376R\\376K\\376T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(254); # \\376
  $rc .= chr(88); # X
  $rc .= chr(254); # \\376
  $rc .= chr(67); # C
  $rc .= chr(254); # \\376
  $rc .= chr(82); # R
  $rc .= chr(254); # \\376
  $rc .= chr(75); # K
  $rc .= chr(254); # \\376
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\EF03' => '
#
# Stub version of: \\EF03
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[1"q' => '
#
# Stub version of: \\E[1"q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(34); # "
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[%p1%dP$<3>' => '
#
# Stub version of: \\E[%p1%dP$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E7\\E[;%i%p1%dx' => '
#
# Stub version of: \\E7\\E[;%i%p1%dx
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\Ea%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\Ea%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[a' => '
#
# Stub version of: \\E[a
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(97); # a

  return $rc;
}
',
          '^C0' => '
#
# Stub version of: ^C0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^C
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[221z' => '
#
# Stub version of: \\E[221z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EW$<7>' => '
#
# Stub version of: \\EW$<7>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1;2Q' => '
#
# Stub version of: \\E[1;2Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\233114z' => '
#
# Stub version of: \\233114z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E(\\EH\\003\\EG0\\EcD' => '
#
# Stub version of: \\E(\\EH\\003\\EG0\\EcD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\EU%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\EU%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E\\003\\E9' => '
#
# Stub version of: \\E\\003\\E9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\EX\\r' => '
#
# Stub version of: \\EX\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[139q' => '
#
# Stub version of: \\E[139q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(57); # 9
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\ENB' => '
#
# Stub version of: \\ENB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\EOS' => '
#
# Stub version of: \\EOS
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E[34h\\E[?25h' => '
#
# Stub version of: \\E[34h\\E[?25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p5%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%t;7%;%?%p7%t;8%;m%?%p9%t\\E)0\\016%e\\E(B\\017%;' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p5%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%t;7%;%?%p7%t;8%;m%?%p9%t\\E)0\\016%e\\E(B\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[0]); # %p1
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(41); # )
    $rc .= chr(48); # 0
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\377\\336' => '
#
# Stub version of: \\377\\336
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(222); # \\336

  return $rc;
}
',
          '\\E[5n' => '
#
# Stub version of: \\E[5n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\E!a\\r' => '
#
# Stub version of: \\E!a\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(97); # a
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\0p' => '
#
# Stub version of: \\0p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[J$<6>' => '
#
# Stub version of: \\E[J$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E^C\\r' => '
#
# Stub version of: \\E^C\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^C
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[5;50m' => '
#
# Stub version of: \\E[5;50m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '^NR' => '
#
# Stub version of: ^NR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^N
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\EA$<20>' => '
#
# Stub version of: \\EA$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO4B' => '
#
# Stub version of: \\EO4B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(52); # 4
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[1;1H\\E[2J' => '
#
# Stub version of: \\E[1;1H\\E[2J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\233305z' => '
#
# Stub version of: \\233305z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[102z' => '
#
# Stub version of: \\E[102z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\377\\311' => '
#
# Stub version of: \\377\\311
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(201); # \\311

  return $rc;
}
',
          '\\Eu' => '
#
# Stub version of: \\Eu
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\ENF' => '
#
# Stub version of: \\ENF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E[Z' => '
#
# Stub version of: \\E[Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\E>\\E[?3l\\E[?4l\\E[?7h\\E[?8h\\E[1;24r' => '
#
# Stub version of: \\E>\\E[?3l\\E[?4l\\E[?7h\\E[?8h\\E[1;24r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\026\\n\\0\\0\\0\\0' => '
#
# Stub version of: \\026\\n\\0\\0\\0\\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(22); # \\026
  $rc .= chr(10); # \\n
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0

  return $rc;
}
',
          '\\E[3u\\027' => '
#
# Stub version of: \\E[3u\\027
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(117); # u
  $rc .= chr(23); # \\027

  return $rc;
}
',
          '\\E&f1a%p1%dk%p2%l%dL%p2%s' => '
#
# Stub version of: \\E&f1a%p1%dk%p2%l%dL%p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(102); # f
  $rc .= chr(49); # 1
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(107); # k
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\E[24;2~' => '
#
# Stub version of: \\E[24;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\Ew@%p1%{48}%+%c%p2%{32}%+%c%p3%{32}%+%c$<5>' => '
#
# Stub version of: \\Ew@%p1%{48}%+%c%p2%{32}%+%c%p3%{32}%+%c$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(64); # @
  push(@iparam, $param[0]); # %p1
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[2]); # %p3
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[20;6~' => '
#
# Stub version of: \\E[20;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[>1;6C' => '
#
# Stub version of: \\E[>1;6C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(67); # C

  return $rc;
}
',
          'segment advance' => '
#
# Stub version of: segment advance
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(115); # s
  $rc .= chr(101); # e
  $rc .= chr(103); # g
  $rc .= chr(109); # m
  $rc .= chr(101); # e
  $rc .= chr(110); # n
  $rc .= chr(116); # t
  $rc .= chr(32); #  
  $rc .= chr(97); # a
  $rc .= chr(100); # d
  $rc .= chr(118); # v
  $rc .= chr(97); # a
  $rc .= chr(110); # n
  $rc .= chr(99); # c
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\EO6D' => '
#
# Stub version of: \\EO6D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(54); # 6
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[r\\E[m\\E[2J\\E[H\\E[?7h\\E[?1;3;4;6l\\E[4l' => '
#
# Stub version of: \\E[r\\E[m\\E[2J\\E[H\\E[?7h\\E[?1;3;4;6l\\E[4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[3;J' => '
#
# Stub version of: \\E[3;J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\EGu' => '
#
# Stub version of: \\EGu
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\E&f0a%p1%dk%p2%l%Pa%?%ga%t%ga%d%e1%;d3L%?%ga%!%t%{32}%c%;%p2%s\\E%{111}%p1%+%c\\r' => '
#
# Stub version of: \\E&f0a%p1%dk%p2%l%Pa%?%ga%t%ga%d%e1%;d3L%?%ga%!%t%{32}%c%;%p2%s\\E%{111}%p1%+%c\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(102); # f
  $rc .= chr(48); # 0
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(107); # k
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $dynamicp->[0] = pop(@iparam); # %Pa
  if (do { # %?
           push(@iparam, $dynamicp->[0]); # %ga
           pop(@iparam);
         }) { # %t
    push(@iparam, $dynamicp->[0]); # %ga
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  }
  else { # %e
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(100); # d
  $rc .= chr(51); # 3
  $rc .= chr(76); # L
  if (do { # %?
           push(@iparam, $dynamicp->[0]); # %ga
           push(@iparam, ! pop(@iparam)); # %!
           pop(@iparam);
         }) { # %t
    push(@iparam, 32); # %{32}
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  } # %;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(27); # \\E
  push(@iparam, 111); # %{111}
  push(@iparam, $param[0]); # %p1
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\2330W' => '
#
# Stub version of: \\2330W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\E[2 q' => '
#
# Stub version of: \\E[2 q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(32); #  
  $rc .= chr(113); # q

  return $rc;
}
',
          '^^b' => '
#
# Stub version of: ^^b
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E[016q' => '
#
# Stub version of: \\E[016q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[>6h' => '
#
# Stub version of: \\E[>6h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(54); # 6
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\Ed/' => '
#
# Stub version of: \\Ed/
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /

  return $rc;
}
',
          '\\233308z' => '
#
# Stub version of: \\233308z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[0;0i' => '
#
# Stub version of: \\E[0;0i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\013%p1%{64}%+%c' => '
#
# Stub version of: \\013%p1%{64}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  push(@iparam, $param[0]); # %p1
  push(@iparam, 64); # %{64}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E7\\E[60;0;0;36p\\E8' => '
#
# Stub version of: \\E7\\E[60;0;0;36p\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\EE$<1.5*>' => '
#
# Stub version of: \\EE$<1.5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ec$<50>' => '
#
# Stub version of: \\Ec$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E!g\\r' => '
#
# Stub version of: \\E!g\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(103); # g
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EO1;4A' => '
#
# Stub version of: \\EO1;4A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E7\\E[255;0;0;76;89;100p\\E8\\E[J' => '
#
# Stub version of: \\E7\\E[255;0;0;76;89;100p\\E8\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E\\016$<13>' => '
#
# Stub version of: \\E\\016$<13>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(14); # \\016
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^Q' => '
#
# Stub version of: ^^Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\377\\365' => '
#
# Stub version of: \\377\\365
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(245); # \\365

  return $rc;
}
',
          '\\001<2.3*/>' => '
#
# Stub version of: \\001<2.3*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(1); # \\001
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(46); # .
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?1;41s\\E[?1;41h\\E=' => '
#
# Stub version of: \\E[?1;41s\\E[?1;41h\\E=
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =

  return $rc;
}
',
          '\\E)0$<5>' => '
#
# Stub version of: \\E)0$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO\\Eq\\EG\\EvK5' => '
#
# Stub version of: \\EO\\Eq\\EG\\EvK5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(75); # K
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E|' => '
#
# Stub version of: \\E|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\233%i%p1%d;%p2%dr' => '
#
# Stub version of: \\233%i%p1%d;%p2%dr
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\377\\354' => '
#
# Stub version of: \\377\\354
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(236); # \\354

  return $rc;
}
',
          '\\E7\\E[255;0;0;76;178;178p\\E8\\E[J' => '
#
# Stub version of: \\E7\\E[255;0;0;76;178;178p\\E8\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(56); # 8
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\233%p1%dD' => '
#
# Stub version of: \\233%p1%dD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E/>2l' => '
#
# Stub version of: \\E/>2l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(50); # 2
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EOl' => '
#
# Stub version of: \\EOl
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[m\\017' => '
#
# Stub version of: \\E[m\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\E%!1\\E[90;1"p' => '
#
# Stub version of: \\E%!1\\E[90;1"p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(34); # "
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[1;7C' => '
#
# Stub version of: \\E[1;7C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[0%?%p2%t;4%;%?%p3%p1%|%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p2%t;4%;%?%p3%p1%|%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[0]); # %p1
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\007$<500/>' => '
#
# Stub version of: \\007$<500/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(7); # \\007
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[19;1j' => '
#
# Stub version of: \\E[19;1j
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j

  return $rc;
}
',
          '\\E[1;36;44m' => '
#
# Stub version of: \\E[1;36;44m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[13;3~' => '
#
# Stub version of: \\E[13;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E7\\E[60;0;0;24p\\E8' => '
#
# Stub version of: \\E7\\E[60;0;0;24p\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\EcD' => '
#
# Stub version of: \\EcD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\Es2' => '
#
# Stub version of: \\Es2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(50); # 2

  return $rc;
}
',
          '^^t' => '
#
# Stub version of: ^^t
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\233/' => '
#
# Stub version of: \\233/
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(47); # /

  return $rc;
}
',
          '\\E S' => '
#
# Stub version of: \\E S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\EPY99\\:98\\E\\\\\\E[0;98v\\E[2J\\E[H\\E[v' => '
#
# Stub version of: \\EPY99\\:98\\E\\\\\\E[0;98v\\E[2J\\E[H\\E[v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(89); # Y
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\:
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\EH$<10>' => '
#
# Stub version of: \\EH$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1Q\\E[>20;30l\\EP`+x~M\\E\\\\' => '
#
# Stub version of: \\E[1Q\\E[>20;30l\\EP`+x~M\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(96); # `
  $rc .= chr(43); # +
  $rc .= chr(120); # x
  $rc .= chr(126); # ~
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E[>1;3C' => '
#
# Stub version of: \\E[>1;3C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[?7h\\E[?3h\\E[?5l' => '
#
# Stub version of: \\E[?7h\\E[?3h\\E[?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\Ea%i%p1%dR%p2%dC$<30>' => '
#
# Stub version of: \\Ea%i%p1%dR%p2%dC$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(97); # a
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(82); # R
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EP\\EA\\EQ$<130>' => '
#
# Stub version of: \\EP\\EA\\EQ$<130>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0;23r\\Ex\\Ey\\E[2;0j\\E[3;3j\\E[4;0j\\E[5;0j\\E[6;0j\\E[7;0j\\E[8;0j\\E[9;1j\\E[10;0j\\E[15;0j\\E[16;1j\\E[19;0j\\E[20;1j\\E[29;0j\\E[1;24r' => '
#
# Stub version of: \\E[0;23r\\Ex\\Ey\\E[2;0j\\E[3;3j\\E[4;0j\\E[5;0j\\E[6;0j\\E[7;0j\\E[8;0j\\E[9;1j\\E[10;0j\\E[15;0j\\E[16;1j\\E[19;0j\\E[20;1j\\E[29;0j\\E[1;24r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\377\\234' => '
#
# Stub version of: \\377\\234
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(156); # \\234

  return $rc;
}
',
          '\\E[1M$<5*>' => '
#
# Stub version of: \\E[1M$<5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '%?%p5%t\\E[0t%;%?%p3%p1%|%t\\E[1t%;%?%p2%t\\E[2t%;%?%p4%t\\E[3t%;%?%p1%p2%p3%p4%p5%|%|%|%|%t\\E[7m%e\\E[m%;%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: %?%p5%t\\E[0t%;%?%p3%p1%|%t\\E[1t%;%?%p2%t\\E[2t%;%?%p4%t\\E[3t%;%?%p1%p2%p3%p4%p5%|%|%|%|%t\\E[7m%e\\E[m%;%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(48); # 0
    $rc .= chr(116); # t
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[0]); # %p1
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(49); # 1
    $rc .= chr(116); # t
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(50); # 2
    $rc .= chr(116); # t
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(51); # 3
    $rc .= chr(116); # t
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[1]); # %p2
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[3]); # %p4
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(55); # 7
    $rc .= chr(109); # m
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(109); # m
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\E[1$}\\r\\E[K' => '
#
# Stub version of: \\E[1$}\\r\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(125); # }
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E#A' => '
#
# Stub version of: \\E#A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E_F\\E\\\\' => '
#
# Stub version of: \\E_F\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E[5m' => '
#
# Stub version of: \\E[5m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\023\\ER$<60>' => '
#
# Stub version of: \\023\\ER$<60>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(19); # \\023
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[=5h' => '
#
# Stub version of: \\E[=5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\001C4\\,\\001c7\\,' => '
#
# Stub version of: \\001C4\\,\\001c7\\,
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(1); # \\001
  $rc .= chr(67); # C
  $rc .= chr(52); # 4
  $rc .= chr(128); # \\,
  $rc .= chr(1); # \\001
  $rc .= chr(99); # c
  $rc .= chr(55); # 7
  $rc .= chr(128); # \\,

  return $rc;
}
',
          '\\E4' => '
#
# Stub version of: \\E4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\Ey$<260>' => '
#
# Stub version of: \\Ey$<260>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^FA' => '
#
# Stub version of: ^^FA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(70); # F
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\EsH' => '
#
# Stub version of: \\EsH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[1;25r\\E[25;1H' => '
#
# Stub version of: \\E[1;25r\\E[25;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[M$<3>' => '
#
# Stub version of: \\E[M$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[7m$<5/>' => '
#
# Stub version of: \\E[7m$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%i%p1%dd' => '
#
# Stub version of: \\E[%i%p1%dd
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\EY$<5>' => '
#
# Stub version of: \\EY$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EF18' => '
#
# Stub version of: \\EF18
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[?4l' => '
#
# Stub version of: \\E[?4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\005%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\005%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(5); # \\005
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '^B-\\r' => '
#
# Stub version of: ^B-\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(45); # -
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E\\023\\E0' => '
#
# Stub version of: \\E\\023\\E0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\036F}11' => '
#
# Stub version of: \\036F}11
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(125); # }
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\23313~' => '
#
# Stub version of: \\23313~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[?3i' => '
#
# Stub version of: \\E[?3i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E>\\E[?1l\\E[?7h\\E[0;10;39;49m' => '
#
# Stub version of: \\E>\\E[?1l\\E[?7h\\E[0;10;39;49m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\0^^E' => '
#
# Stub version of: \\0^^E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(0); # ^^
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\E[A$<2/>' => '
#
# Stub version of: \\E[A$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EDF\\EC\\EG0\\Er\\E(\\E%EX' => '
#
# Stub version of: \\EDF\\EC\\EG0\\Er\\E(\\E%EX
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(69); # E
  $rc .= chr(88); # X

  return $rc;
}
',
          '\\E0%p5%{64}%+%p4%{2}%*%+%p3%{16}%*%+%p2%{32}%*%+%p1%{17}%*%+%c' => '
#
# Stub version of: \\E0%p5%{64}%+%p4%{2}%*%+%p3%{16}%*%+%p2%{32}%*%+%p1%{17}%*%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  push(@iparam, $param[4]); # %p5
  push(@iparam, 64); # %{64}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, $param[3]); # %p4
  push(@iparam, 2); # %{2}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, $param[2]); # %p3
  push(@iparam, 16); # %{16}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, $param[0]); # %p1
  push(@iparam, 17); # %{17}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[5h' => '
#
# Stub version of: \\E[5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EFc' => '
#
# Stub version of: \\EFc
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E+$<50>' => '
#
# Stub version of: \\E+$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E!%+%p1%{32}%+%p2%{32} cud1=\\026' => '
#
# Stub version of: \\E!%+%p1%{32}%+%p2%{32} cud1=\\026
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  $rc .= chr(32); #  
  $rc .= chr(99); # c
  $rc .= chr(117); # u
  $rc .= chr(100); # d
  $rc .= chr(49); # 1
  $rc .= chr(61); # =
  $rc .= chr(22); # \\026

  return $rc;
}
',
          '\\23319~' => '
#
# Stub version of: \\23319~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[=119h' => '
#
# Stub version of: \\E[=119h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[1;1H' => '
#
# Stub version of: \\E[1;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\Ec\\E[5;1v\\E[1;1;126w\\E[<2h' => '
#
# Stub version of: \\Ec\\E[5;1v\\E[1;1;126w\\E[<2h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E&f%p1%dk%p2%l%dL%p2%s' => '
#
# Stub version of: \\E&f%p1%dk%p2%l%dL%p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(102); # f
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(107); # k
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\E[?5h$<100/>\\E[?5l' => '
#
# Stub version of: \\E[?5h$<100/>\\E[?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          'A print' => '
#
# Stub version of: A print
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(65); # A
  $rc .= chr(32); #  
  $rc .= chr(112); # p
  $rc .= chr(114); # r
  $rc .= chr(105); # i
  $rc .= chr(110); # n
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\E[?5l\\E[47h\\E[40l\\E[1;24r' => '
#
# Stub version of: \\E[?5l\\E[47h\\E[40l\\E[1;24r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[?5h\\E[?5l' => '
#
# Stub version of: \\E[?5h\\E[?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[V\\E[24;1f\\E[?38h' => '
#
# Stub version of: \\E[V\\E[24;1f\\E[?38h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(86); # V
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(102); # f
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[1K$<30>' => '
#
# Stub version of: \\E[1K$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?62;1;6c' => '
#
# Stub version of: \\E[?62;1;6c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\007$<80>\\007$<80>\\007' => '
#
# Stub version of: \\007$<80>\\007$<80>\\007
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(7); # \\007
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(7); # \\007
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(7); # \\007

  return $rc;
}
',
          '\\E`1' => '
#
# Stub version of: \\E`1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\233108z' => '
#
# Stub version of: \\233108z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EeF\\E`\\:$<70>' => '
#
# Stub version of: \\EeF\\E`\\:$<70>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?1l\\E=\\E[?7h' => '
#
# Stub version of: \\E[?1l\\E=\\E[?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\ED$<5>' => '
#
# Stub version of: \\ED$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ET\\EF \\011' => '
#
# Stub version of: \\ET\\EF \\011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(32); #  
  $rc .= chr(9); # \\011

  return $rc;
}
',
          '\\E[45~' => '
#
# Stub version of: \\E[45~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E?y' => '
#
# Stub version of: \\E?y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(121); # y

  return $rc;
}
',
          '\\EI$<5.5>' => '
#
# Stub version of: \\EI$<5.5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ei\\r' => '
#
# Stub version of: \\Ei\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(105); # i
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^^^R[' => '
#
# Stub version of: ^^^R[
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(0); # ^R
  $rc .= chr(91); # [

  return $rc;
}
',
          '\\E[?1047l\\E[?1048l' => '
#
# Stub version of: \\E[?1047l\\E[?1048l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EZ2%p1%{63}%+%c%p2%s\\177' => '
#
# Stub version of: \\EZ2%p1%{63}%+%c%p2%s\\177
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(90); # Z
  $rc .= chr(50); # 2
  push(@iparam, $param[0]); # %p1
  push(@iparam, 63); # %{63}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(127); # \\177

  return $rc;
}
',
          '\\E[7u\\027' => '
#
# Stub version of: \\E[7u\\027
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(117); # u
  $rc .= chr(23); # \\027

  return $rc;
}
',
          '\\E^M' => '
#
# Stub version of: \\E^M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^M

  return $rc;
}
',
          '\\E[8;3~' => '
#
# Stub version of: \\E[8;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[H$<1>' => '
#
# Stub version of: \\E[H$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[31\\^' => '
#
# Stub version of: \\E[31\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\016A\\016\\035$<65>' => '
#
# Stub version of: \\016A\\016\\035$<65>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  $rc .= chr(65); # A
  $rc .= chr(14); # \\016
  $rc .= chr(29); # \\035
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E7R3\\E0@' => '
#
# Stub version of: \\E7R3\\E0@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(82); # R
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\016$<200/>' => '
#
# Stub version of: \\016$<200/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EF\\Ef7;' => '
#
# Stub version of: \\EF\\Ef7;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E_1' => '
#
# Stub version of: \\E_1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[?7l' => '
#
# Stub version of: \\E[?7l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\013%p1%{64}%+%c\\E\\005%p2%2d' => '
#
# Stub version of: \\013%p1%{64}%+%c\\E\\005%p2%2d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  push(@iparam, $param[0]); # %p1
  push(@iparam, 64); # %{64}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(27); # \\E
  $rc .= chr(5); # \\005
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d

  return $rc;
}
',
          '\\E[%y' => '
#
# Stub version of: \\E[%y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(37); # %
  $rc .= chr(121); # y

  return $rc;
}
',
          '\\EOx' => '
#
# Stub version of: \\EOx
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\E[?5l\\E[36*|\\E[36t\\E[40l\\E[1;36r' => '
#
# Stub version of: \\E[?5l\\E[36*|\\E[36t\\E[40l\\E[1;36r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(42); # *
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(116); # t
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\23326~' => '
#
# Stub version of: \\23326~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[4h\\E[2Q\\E[P\\E[4l\\E[0Q' => '
#
# Stub version of: \\E[4h\\E[2Q\\E[P\\E[4l\\E[0Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(80); # P
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\EF1' => '
#
# Stub version of: \\EF1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E0Q' => '
#
# Stub version of: \\E0Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E`\\:$<100>' => '
#
# Stub version of: \\E`\\:$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E)0\\E?6l\\E?5l' => '
#
# Stub version of: \\E)0\\E?6l\\E?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\233?25h' => '
#
# Stub version of: \\233?25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[%i%p1%dG' => '
#
# Stub version of: \\E[%i%p1%dG
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\EwG\\Ee($<140>' => '
#
# Stub version of: \\EwG\\Ee($<140>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(40); # (
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\2331K' => '
#
# Stub version of: \\2331K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E[0K$<30>' => '
#
# Stub version of: \\E[0K$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E%?%p1%{1}%=%tD%e%p1%{3}%=%tF%e%p1%{4}%=%tA%e%p1%{6}%=%tC%e%p1%{64}%+%c%;' => '
#
# Stub version of: \\E%?%p1%{1}%=%tD%e%p1%{3}%=%tF%e%p1%{4}%=%tA%e%p1%{6}%=%tC%e%p1%{64}%+%c%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(68); # D
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(70); # F
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(65); # A
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(67); # C
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    push(@iparam, 64); # %{64}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  } # %;

  return $rc;
}
',
          '\\E[>2h' => '
#
# Stub version of: \\E[>2h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\En' => '
#
# Stub version of: \\En
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(110); # n

  return $rc;
}
',
          '^^4' => '
#
# Stub version of: ^^4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\ENp' => '
#
# Stub version of: \\ENp
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\Ev\\Eu\\EK' => '
#
# Stub version of: \\Ev\\Eu\\EK
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K

  return $rc;
}
',
          '^^^RW' => '
#
# Stub version of: ^^^RW
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(0); # ^R
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\EG0\\E(\\EH\\003' => '
#
# Stub version of: \\EG0\\E(\\EH\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '\\E!U' => '
#
# Stub version of: \\E!U
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(85); # U

  return $rc;
}
',
          '\\E[1;7F' => '
#
# Stub version of: \\E[1;7F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E[1;2H' => '
#
# Stub version of: \\E[1;2H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(72); # H

  return $rc;
}
',
          '^B.\\r' => '
#
# Stub version of: ^B.\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(46); # .
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%p1%dP' => '
#
# Stub version of: \\E[%p1%dP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[?2h\\E[?3l\\E[?5h\\E[?7h\\E[?8h\\E>\\E[?1l\\E G\\E[?42l\\E[?4l' => '
#
# Stub version of: \\E[?2h\\E[?3l\\E[?5h\\E[?7h\\E[?8h\\E>\\E[?1l\\E G\\E[?42l\\E[?4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EAE' => '
#
# Stub version of: \\EAE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\E-' => '
#
# Stub version of: \\E-
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(45); # -

  return $rc;
}
',
          '\\EW$<11>' => '
#
# Stub version of: \\EW$<11>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\023\\E6' => '
#
# Stub version of: \\E\\023\\E6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  $rc .= chr(27); # \\E
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\377\\324' => '
#
# Stub version of: \\377\\324
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(212); # \\324

  return $rc;
}
',
          '\\EA\\r' => '
#
# Stub version of: \\EA\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(13); # \\r

  return $rc;
}
',
          'j\\352k\\353l\\354m\\355n\\356q\\361t\\364u\\365v\\366w\\367x\\370' => '
#
# Stub version of: j\\352k\\353l\\354m\\355n\\356q\\361t\\364u\\365v\\366w\\367x\\370
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(106); # j
  $rc .= chr(234); # \\352
  $rc .= chr(107); # k
  $rc .= chr(235); # \\353
  $rc .= chr(108); # l
  $rc .= chr(236); # \\354
  $rc .= chr(109); # m
  $rc .= chr(237); # \\355
  $rc .= chr(110); # n
  $rc .= chr(238); # \\356
  $rc .= chr(113); # q
  $rc .= chr(241); # \\361
  $rc .= chr(116); # t
  $rc .= chr(244); # \\364
  $rc .= chr(117); # u
  $rc .= chr(245); # \\365
  $rc .= chr(118); # v
  $rc .= chr(246); # \\366
  $rc .= chr(119); # w
  $rc .= chr(247); # \\367
  $rc .= chr(120); # x
  $rc .= chr(248); # \\370

  return $rc;
}
',
          '\\E[>1;5A' => '
#
# Stub version of: \\E[>1;5A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E^]' => '
#
# Stub version of: \\E^]
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^]

  return $rc;
}
',
          '\\r$<20>' => '
#
# Stub version of: \\r$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\233203z' => '
#
# Stub version of: \\233203z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EP' => '
#
# Stub version of: \\EP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[%p1%dv' => '
#
# Stub version of: \\E[%p1%dv
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\0j' => '
#
# Stub version of: \\0j
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(106); # j

  return $rc;
}
',
          '^^>' => '
#
# Stub version of: ^^>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ELZ\\EKA0\\ELF7l\\177 @' => '
#
# Stub version of: \\ELZ\\EKA0\\ELF7l\\177 @
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(90); # Z
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(65); # A
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(70); # F
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(127); # \\177
  $rc .= chr(32); #  
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\244' => '
#
# Stub version of: \\244
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(164); # \\244

  return $rc;
}
',
          'F3' => '
#
# Stub version of: F3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(51); # 3

  return $rc;
}
',
          '^V^A^P' => '
#
# Stub version of: ^V^A^P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^A
  $rc .= chr(0); # ^P

  return $rc;
}
',
          '\\E[%p1%dP$<7>' => '
#
# Stub version of: \\E[%p1%dP$<7>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[J$<40>' => '
#
# Stub version of: \\E[J$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ef0' => '
#
# Stub version of: \\Ef0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E_%p1%{65}%+%c%p2%{65}%+%c' => '
#
# Stub version of: \\E_%p1%{65}%+%c%p2%{65}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  push(@iparam, $param[0]); # %p1
  push(@iparam, 65); # %{65}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 65); # %{65}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\Ev  \\001 p\\Ep\\r\\n' => '
#
# Stub version of: \\Ev  \\001 p\\Ep\\r\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(1); # \\001
  $rc .= chr(32); #  
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '~\\034$<6>' => '
#
# Stub version of: ~\\034$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(28); # \\034
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\036\\:\\264\\026%%' => '
#
# Stub version of: \\036\\:\\264\\026%%
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(128); # \\:
  $rc .= chr(180); # \\264
  $rc .= chr(22); # \\026
  $rc .= \'%\';

  return $rc;
}
',
          '\\E[004z' => '
#
# Stub version of: \\E[004z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '^^k' => '
#
# Stub version of: ^^k
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\Ec%?%p1%{0}%=%t1%e%p1%{1}%=%t2%e%p1%{2}%=%t3%e%p1%{3}%=%t>%e%p1%{4}%=%t4%e%p1%{5}%=%t7%e%p1%{6}%=%t5%e%p1%{7}%=%t0%e%p1%{8}%=%t8%e%p1%{9}%=%t9%e%p1%{10}%=%t\\:%e%p1%{11}%=%t;%e%p1%{12}%=%t<%e%p1%{13}%=%t=%e%p1%{14}%=%t6%e?' => '
#
# Stub version of: \\Ec%?%p1%{0}%=%t1%e%p1%{1}%=%t2%e%p1%{2}%=%t3%e%p1%{3}%=%t>%e%p1%{4}%=%t4%e%p1%{5}%=%t7%e%p1%{6}%=%t5%e%p1%{7}%=%t0%e%p1%{8}%=%t8%e%p1%{9}%=%t9%e%p1%{10}%=%t\\:%e%p1%{11}%=%t;%e%p1%{12}%=%t<%e%p1%{13}%=%t=%e%p1%{14}%=%t6%e?
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 1); # %{1}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 2); # %{2}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(62); # >
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 5); # %{5}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 7); # %{7}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 8); # %{8}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(56); # 8
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 9); # %{9}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(57); # 9
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 10); # %{10}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(128); # \\:
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 11); # %{11}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 12); # %{12}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(60); # <
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 13); # %{13}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(61); # =
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 14); # %{14}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
  }
  else { # %e
    $rc .= chr(63); # ?
  } # ,
  return $rc;
}
',
          '\\E1\\s\\s' => '
#
# Stub version of: \\E1\\s\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(32); # \\s
  $rc .= chr(32); # \\s

  return $rc;
}
',
          'jYk?lZm@nEqDt4uCvAwBx3' => '
#
# Stub version of: jYk?lZm@nEqDt4uCvAwBx3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(106); # j
  $rc .= chr(89); # Y
  $rc .= chr(107); # k
  $rc .= chr(63); # ?
  $rc .= chr(108); # l
  $rc .= chr(90); # Z
  $rc .= chr(109); # m
  $rc .= chr(64); # @
  $rc .= chr(110); # n
  $rc .= chr(69); # E
  $rc .= chr(113); # q
  $rc .= chr(68); # D
  $rc .= chr(116); # t
  $rc .= chr(52); # 4
  $rc .= chr(117); # u
  $rc .= chr(67); # C
  $rc .= chr(118); # v
  $rc .= chr(65); # A
  $rc .= chr(119); # w
  $rc .= chr(66); # B
  $rc .= chr(120); # x
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[0%?%p1%t;2;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;30;1%;%?%p6%t;1%;m' => '
#
# Stub version of: \\E[0%?%p1%t;2;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;30;1%;%?%p6%t;1%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(51); # 3
    $rc .= chr(48); # 0
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '^Ah\\r' => '
#
# Stub version of: ^Ah\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(104); # h
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E&q3t0{0H \\E&w0f115n1I \\E&w0f1n2I \\E&w2f1i0d0u22l0S \\E&w2f2i0d23u23l0S \\E&w7f2p1I \\r' => '
#
# Stub version of: \\E&q3t0{0H \\E&w0f115n1I \\E&w0f1n2I \\E&w2f1i0d0u22l0S \\E&w2f2i0d23u23l0S \\E&w7f2p1I \\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(113); # q
  $rc .= chr(51); # 3
  $rc .= chr(116); # t
  $rc .= chr(48); # 0
  $rc .= chr(123); # {
  $rc .= chr(48); # 0
  $rc .= chr(72); # H
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(48); # 0
  $rc .= chr(102); # f
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(110); # n
  $rc .= chr(49); # 1
  $rc .= chr(73); # I
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(48); # 0
  $rc .= chr(102); # f
  $rc .= chr(49); # 1
  $rc .= chr(110); # n
  $rc .= chr(50); # 2
  $rc .= chr(73); # I
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(50); # 2
  $rc .= chr(102); # f
  $rc .= chr(49); # 1
  $rc .= chr(105); # i
  $rc .= chr(48); # 0
  $rc .= chr(100); # d
  $rc .= chr(48); # 0
  $rc .= chr(117); # u
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(48); # 0
  $rc .= chr(83); # S
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(50); # 2
  $rc .= chr(102); # f
  $rc .= chr(50); # 2
  $rc .= chr(105); # i
  $rc .= chr(48); # 0
  $rc .= chr(100); # d
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(117); # u
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(48); # 0
  $rc .= chr(83); # S
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(55); # 7
  $rc .= chr(102); # f
  $rc .= chr(50); # 2
  $rc .= chr(112); # p
  $rc .= chr(49); # 1
  $rc .= chr(73); # I
  $rc .= chr(32); #  
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E\\023\\E9' => '
#
# Stub version of: \\E\\023\\E9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\E[60;0;0;18p\\E[60;1H\\E[K' => '
#
# Stub version of: \\E[60;0;0;18p\\E[60;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\377\\220' => '
#
# Stub version of: \\377\\220
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(144); # \\220

  return $rc;
}
',
          '\\EG6' => '
#
# Stub version of: \\EG6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\233%p1%dM' => '
#
# Stub version of: \\233%p1%dM
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\036F}01\\022' => '
#
# Stub version of: \\036F}01\\022
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(125); # }
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(18); # \\022

  return $rc;
}
',
          '\\233211z' => '
#
# Stub version of: \\233211z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[4%p1%\'0\'%+%Pa%?%ga%\'0\'%=%t0%e%ga%\'1\'%=%t4%e%ga%\'2\'%=%t2%e%ga%\'3\'%=%t6%e%ga%\'4\'%=%t1%e%ga%\'5\'%=%t5%e%ga%\'6\'%=%t3%e7%;m' => '
#
# Stub version of: \\E[4%p1%\'0\'%+%Pa%?%ga%\'0\'%=%t0%e%ga%\'1\'%=%t4%e%ga%\'2\'%=%t2%e%ga%\'3\'%=%t6%e%ga%\'4\'%=%t1%e%ga%\'5\'%=%t5%e%ga%\'6\'%=%t3%e7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  push(@iparam, $param[0]); # %p1
  push(@iparam, chr(48)); # %\'0\'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $dynamicp->[0] = pop(@iparam); # %Pa
  if (do { # %?
           push(@iparam, $dynamicp->[0]); # %ga
           push(@iparam, chr(48)); # %\'0\'
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, chr(49)); # %\'1\'
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, chr(50)); # %\'2\'
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, chr(51)); # %\'3\'
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, chr(52)); # %\'4\'
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, chr(53)); # %\'5\'
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, chr(54)); # %\'6\'
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
  }
  else { # %e
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[23;6~' => '
#
# Stub version of: \\E[23;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^VE\\r' => '
#
# Stub version of: ^VE\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(69); # E
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[i$<100>' => '
#
# Stub version of: \\E[i$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(105); # i
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\011$<4>' => '
#
# Stub version of: \\011$<4>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(9); # \\011
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EOZ' => '
#
# Stub version of: \\EOZ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\E[2C' => '
#
# Stub version of: \\E[2C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(67); # C

  return $rc;
}
',
          '^M^U' => '
#
# Stub version of: ^M^U
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^M
  $rc .= chr(0); # ^U

  return $rc;
}
',
          '\\EOc' => '
#
# Stub version of: \\EOc
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\EY%p1%{32}%+%c%p2%{32}%+%c$<5>' => '
#
# Stub version of: \\EY%p1%{32}%+%c%p2%{32}%+%c$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\037wor h\\r' => '
#
# Stub version of: \\037wor h\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(119); # w
  $rc .= chr(111); # o
  $rc .= chr(114); # r
  $rc .= chr(32); #  
  $rc .= chr(104); # h
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\2330p' => '
#
# Stub version of: \\2330p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E>\\E[?1l\\E[?3l\\E[4l\\E[?7h' => '
#
# Stub version of: \\E>\\E[?1l\\E[?3l\\E[4l\\E[?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[2;7;50m' => '
#
# Stub version of: \\E[2;7;50m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EO2S' => '
#
# Stub version of: \\EO2S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(50); # 2
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\EL$<10*/>' => '
#
# Stub version of: \\EL$<10*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1;5B' => '
#
# Stub version of: \\E[1;5B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E3h' => '
#
# Stub version of: \\E3h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\0c' => '
#
# Stub version of: \\0c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(99); # c

  return $rc;
}
',
          'f4' => '
#
# Stub version of: f4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(102); # f
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\E[5;0|' => '
#
# Stub version of: \\E[5;0|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\E[0%?%p1%p3%|%t;7%;%?%p2%t;4%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;12%e;10%;m' => '
#
# Stub version of: \\E[0%?%p1%p3%|%t;7%;%?%p2%t;4%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;12%e;10%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(50); # 2
  }
  else { # %e
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(48); # 0
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EM\\E[K$<5/>' => '
#
# Stub version of: \\EM\\E[K$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '^VB\\r' => '
#
# Stub version of: ^VB\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(66); # B
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\23323~' => '
#
# Stub version of: \\23323~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[H\\E[J$<156>\\E[28;0;0;28p' => '
#
# Stub version of: \\E[H\\E[J$<156>\\E[28;0;0;28p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[>51h\\E[1;%p1%dH\\E[2K' => '
#
# Stub version of: \\E[>51h\\E[1;%p1%dH\\E[2K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\EY' => '
#
# Stub version of: \\EY
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y

  return $rc;
}
',
          '\\002\\E{\\003' => '
#
# Stub version of: \\002\\E{\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(2); # \\002
  $rc .= chr(27); # \\E
  $rc .= chr(123); # {
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '^B1\\r' => '
#
# Stub version of: ^B1\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(49); # 1
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E?\\E[3;3|\\E[10;0|\\E[21;1|\\212\\E[6;1|\\E[1{\\E[?99l\\E[2;0|\\E[6;1|\\E[8;0|\\E[19;0|\\E[1{\\E[?99l' => '
#
# Stub version of: \\E?\\E[3;3|\\E[10;0|\\E[21;1|\\212\\E[6;1|\\E[1{\\E[?99l\\E[2;0|\\E[6;1|\\E[8;0|\\E[19;0|\\E[1{\\E[?99l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |
  $rc .= chr(138); # \\212
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(123); # {
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(123); # {
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[H\\E[J$<156>\\E[30;1;0;30p\\E[30;1H\\E[K' => '
#
# Stub version of: \\E[H\\E[J$<156>\\E[30;1;0;30p\\E[30;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E[=7h' => '
#
# Stub version of: \\E[=7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\Et\\r' => '
#
# Stub version of: \\Et\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(116); # t
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\233300z' => '
#
# Stub version of: \\233300z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '^^v' => '
#
# Stub version of: ^^v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\Ex4\\Em71' => '
#
# Stub version of: \\Ex4\\Em71
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(55); # 7
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[%p1%dS\\E[%p1%dB' => '
#
# Stub version of: \\E[%p1%dS\\E[%p1%dB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(83); # S
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\0' => '
#
# Stub version of: \\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0

  return $rc;
}
',
          '\\E[17;5~' => '
#
# Stub version of: \\E[17;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\233310z' => '
#
# Stub version of: \\233310z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[>1l\\E[>2l\\E[>16l\\E[4l\\E[>9l\\E[20l\\E[>3l\\E[>7h\\E[>12l\\E[1Q' => '
#
# Stub version of: \\E[>1l\\E[>2l\\E[>16l\\E[4l\\E[>9l\\E[20l\\E[>3l\\E[>7h\\E[>12l\\E[1Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(57); # 9
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E[<0;<1;<2;<4l\\E[1;1;80w\\E[1;6;<2h' => '
#
# Stub version of: \\E[<0;<1;<2;<4l\\E[1;1;80w\\E[1;6;<2h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EQ\\EO' => '
#
# Stub version of: \\EQ\\EO
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\E[7;m' => '
#
# Stub version of: \\E[7;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\ENt' => '
#
# Stub version of: \\ENt
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(116); # t

  return $rc;
}
',
          '%i\\E[%p1%d;%p2%df' => '
#
# Stub version of: %i\\E[%p1%d;%p2%df
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  map {$param[$_]++} (0..$#param); # %i
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\E.4' => '
#
# Stub version of: \\E.4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(52); # 4

  return $rc;
}
',
          '^A^Z\\r' => '
#
# Stub version of: ^A^Z\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(0); # ^Z
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\233302z' => '
#
# Stub version of: \\233302z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EW$<12>' => '
#
# Stub version of: \\EW$<12>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ERE' => '
#
# Stub version of: \\ERE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\EN%p1%d' => '
#
# Stub version of: \\EN%p1%d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d

  return $rc;
}
',
          '\\E[Q' => '
#
# Stub version of: \\E[Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(81); # Q

  return $rc;
}
',
          '^F5' => '
#
# Stub version of: ^F5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^F
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\EzH' => '
#
# Stub version of: \\EzH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\Eg%p2%{32}%+%c%p1%c' => '
#
# Stub version of: \\Eg%p2%{32}%+%c%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E>\\E F\\E[?1h\\E[?7h\\E[r\\E[2$~' => '
#
# Stub version of: \\E>\\E F\\E[?1h\\E[?7h\\E[r\\E[2$~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E&d%{64}%?%p1%t%{66}%|%;%?%p2%t%{68}%|%;%?%p3%t%{66}%|%;%?%p4%t%{65}%|%;%c' => '
#
# Stub version of: \\E&d%{64}%?%p1%t%{66}%|%;%?%p2%t%{68}%|%;%?%p3%t%{66}%|%;%?%p4%t%{65}%|%;%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  push(@iparam, 64); # %{64}
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    push(@iparam, 66); # %{66}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    push(@iparam, 68); # %{68}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    push(@iparam, 66); # %{66}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 65); # %{65}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '^E^K' => '
#
# Stub version of: ^E^K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^E
  $rc .= chr(0); # ^K

  return $rc;
}
',
          '\\E[7D' => '
#
# Stub version of: \\E[7D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[50m\\E)4\\017' => '
#
# Stub version of: \\E[50m\\E)4\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(52); # 4
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '^^' => '
#
# Stub version of: ^^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^

  return $rc;
}
',
          '\\E<\\E["p\\Ec\\E[?3l\\E]R\\E[40"p\\E[61"p\\E[50;1;2"p' => '
#
# Stub version of: \\E<\\E["p\\Ec\\E[?3l\\E]R\\E[40"p\\E[61"p\\E[50;1;2"p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(82); # R
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(49); # 1
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(34); # "
  $rc .= chr(112); # p

  return $rc;
}
',
          '$<5>' => '
#
# Stub version of: $<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E^T' => '
#
# Stub version of: \\E^T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^T

  return $rc;
}
',
          '\\242' => '
#
# Stub version of: \\242
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(162); # \\242

  return $rc;
}
',
          '\\E[21\\^' => '
#
# Stub version of: \\E[21\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\034\\032$<200/>' => '
#
# Stub version of: \\034\\032$<200/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(28); # \\034
  $rc .= chr(26); # \\032
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EI$<5/>' => '
#
# Stub version of: \\EI$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%i%p1%d`' => '
#
# Stub version of: \\E[%i%p1%d`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(96); # `

  return $rc;
}
',
          '\\ESTART\\r\\E70\\,6\\r\\EEND\\r$<20>' => '
#
# Stub version of: \\ESTART\\r\\E70\\,6\\r\\EEND\\r$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(84); # T
  $rc .= chr(65); # A
  $rc .= chr(82); # R
  $rc .= chr(84); # T
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(54); # 6
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(78); # N
  $rc .= chr(68); # D
  $rc .= chr(13); # \\r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EC' => '
#
# Stub version of: \\EC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\036$<.1*/>' => '
#
# Stub version of: \\036$<.1*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(46); # .
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Et$<5>' => '
#
# Stub version of: \\Et$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(116); # t
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\026$<20>' => '
#
# Stub version of: \\026$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(22); # \\026
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\034R$<15>' => '
#
# Stub version of: \\034R$<15>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(28); # \\034
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E>\\E[?3h\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[1;42r\\E[42;1H' => '
#
# Stub version of: \\E>\\E[?3h\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[1;42r\\E[42;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\037dow %p1%d\\r' => '
#
# Stub version of: \\037dow %p1%d\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(100); # d
  $rc .= chr(111); # o
  $rc .= chr(119); # w
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E_30\\r' => '
#
# Stub version of: \\E_30\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Ev\\E. \\Ee\\Ez_' => '
#
# Stub version of: \\Ev\\E. \\Ee\\Ez_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(95); # _

  return $rc;
}
',
          '0a``aaffggjjkkllmmnnooqqssttuuvvwwxx~~' => '
#
# Stub version of: 0a``aaffggjjkkllmmnnooqqssttuuvvwwxx~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(48); # 0
  $rc .= chr(97); # a
  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[D$<2>' => '
#
# Stub version of: \\E[D$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(68); # D
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[3;2v' => '
#
# Stub version of: \\E[3;2v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\E[19~' => '
#
# Stub version of: \\E[19~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EI1;' => '
#
# Stub version of: \\EI1;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E0A' => '
#
# Stub version of: \\E0A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\Ev\\Eq\\Ez_\\Ee\\Ei\\Eb?\\Ec0' => '
#
# Stub version of: \\Ev\\Eq\\Ez_\\Ee\\Ei\\Eb?\\Ec0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(95); # _
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(27); # \\E
  $rc .= chr(105); # i
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(63); # ?
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\035bac;' => '
#
# Stub version of: \\035bac;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(98); # b
  $rc .= chr(97); # a
  $rc .= chr(99); # c
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\Eg\\Ef\\r\\Eb' => '
#
# Stub version of: \\Eg\\Ef\\r\\Eb
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E[49m\\E[39m' => '
#
# Stub version of: \\E[49m\\E[39m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(57); # 9
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EF10' => '
#
# Stub version of: \\EF10
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E F\\E>\\E[?1l\\E[?7h\\E[?45l' => '
#
# Stub version of: \\E F\\E>\\E[?1l\\E[?7h\\E[?45l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '^AC\\r' => '
#
# Stub version of: ^AC\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(67); # C
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[22;27m' => '
#
# Stub version of: \\E[22;27m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E\\013%p1%2d\\,%p2%2d\\,$<20/>' => '
#
# Stub version of: \\E\\013%p1%2d\\,%p2%2d\\,$<20/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(11); # \\013
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(128); # \\,
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(128); # \\,
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\036FPFF%p1%2.2X' => '
#
# Stub version of: \\036FPFF%p1%2.2X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(80); # P
  $rc .= chr(70); # F
  $rc .= chr(70); # F
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X

  return $rc;
}
',
          '\\233101z' => '
#
# Stub version of: \\233101z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EO5Q' => '
#
# Stub version of: \\EO5Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(53); # 5
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E[3g$<2/>' => '
#
# Stub version of: \\E[3g$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(103); # g
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E?e' => '
#
# Stub version of: \\E?e
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\E(B\\E)0$<40>' => '
#
# Stub version of: \\E(B\\E)0$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO6R' => '
#
# Stub version of: \\EO6R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(54); # 6
  $rc .= chr(82); # R

  return $rc;
}
',
          'help' => '
#
# Stub version of: help
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(104); # h
  $rc .= chr(101); # e
  $rc .= chr(108); # l
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\Ey$<160>' => '
#
# Stub version of: \\Ey$<160>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?H' => '
#
# Stub version of: \\E[?H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[1;6H' => '
#
# Stub version of: \\E[1;6H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E(B\\017' => '
#
# Stub version of: \\E(B\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '^E\\s' => '
#
# Stub version of: ^E\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^E
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E&a%p1%dy%p2%dC$<6/>' => '
#
# Stub version of: \\E&a%p1%dy%p2%dC$<6/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(121); # y
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\0^O' => '
#
# Stub version of: \\0^O
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(0); # ^O

  return $rc;
}
',
          '\\E[0%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '^Ac\\r' => '
#
# Stub version of: ^Ac\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(99); # c
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '4' => '
#
# Stub version of: 4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\EzQ' => '
#
# Stub version of: \\EzQ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\EJ$<14>' => '
#
# Stub version of: \\EJ$<14>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[6$' => '
#
# Stub version of: \\E[6$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\E[2;4;20;30l\\E[?1;10l\\E[12h\\E[?7;8;25h' => '
#
# Stub version of: \\E[2;4;20;30l\\E[?1;10l\\E[12h\\E[?7;8;25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '^^^Rk' => '
#
# Stub version of: ^^^Rk
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(0); # ^R
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;m' => '
#
# Stub version of: \\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[=6;<5' => '
#
# Stub version of: \\E[=6;<5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\027$<2.3*/>' => '
#
# Stub version of: \\027$<2.3*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(23); # \\027
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(46); # .
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\036FQ5\\036FW\\036FJ\\036F\\^\\036FX004F\\036O\\036FS00' => '
#
# Stub version of: \\036FQ5\\036FW\\036FJ\\036F\\^\\036FX004F\\036O\\036FS00
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(81); # Q
  $rc .= chr(53); # 5
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(87); # W
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(74); # J
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(128); # \\^
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(88); # X
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(70); # F
  $rc .= chr(30); # \\036
  $rc .= chr(79); # O
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[%i%p1%{1}%+%d;%p2%dH$<5>' => '
#
# Stub version of: \\E[%i%p1%{1}%+%d;%p2%dH$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  push(@iparam, 1); # %{1}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E4H' => '
#
# Stub version of: \\E4H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E&a0y0C\\EA' => '
#
# Stub version of: \\E&a0y0C\\EA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  $rc .= chr(48); # 0
  $rc .= chr(121); # y
  $rc .= chr(48); # 0
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h' => '
#
# Stub version of: \\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E7\\E[0U' => '
#
# Stub version of: \\E7\\E[0U
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(85); # U

  return $rc;
}
',
          '\\E[>7h' => '
#
# Stub version of: \\E[>7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\035era;\\n\\035rup;' => '
#
# Stub version of: \\035era;\\n\\035rup;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(101); # e
  $rc .= chr(114); # r
  $rc .= chr(97); # a
  $rc .= chr(59); # ;
  $rc .= chr(10); # \\n
  $rc .= chr(29); # \\035
  $rc .= chr(114); # r
  $rc .= chr(117); # u
  $rc .= chr(112); # p
  $rc .= chr(59); # ;

  return $rc;
}
',
          '%i\\E[%p1%d;%p2%dr' => '
#
# Stub version of: %i\\E[%p1%d;%p2%dr
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  map {$param[$_]++} (0..$#param); # %i
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\EM$<20*>' => '
#
# Stub version of: \\EM$<20*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[12~' => '
#
# Stub version of: \\E[12~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[0m\\E(K\\017' => '
#
# Stub version of: \\E[0m\\E(K\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(75); # K
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\E[7s\\E[2;3;4;20;?5;?6l\\E[12;?7h\\E[2Q\\E[0;1(D\\E[8s' => '
#
# Stub version of: \\E[7s\\E[2;3;4;20;?5;?6l\\E[12;?7h\\E[2Q\\E[0;1(D\\E[8s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(40); # (
  $rc .= chr(68); # D
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\EA$<2/>' => '
#
# Stub version of: \\EA$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EyP' => '
#
# Stub version of: \\EyP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\EM$<10*/>' => '
#
# Stub version of: \\EM$<10*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EP$<2>' => '
#
# Stub version of: \\EP$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E?u' => '
#
# Stub version of: \\E?u
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\E0' => '
#
# Stub version of: \\E0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E7\\E[U' => '
#
# Stub version of: \\E7\\E[U
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(85); # U

  return $rc;
}
',
          '\\EB$<6>' => '
#
# Stub version of: \\EB$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(66); # B
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EZ\\E3\\E_c' => '
#
# Stub version of: \\EZ\\E3\\E_c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(90); # Z
  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E[A' => '
#
# Stub version of: \\E[A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E(B' => '
#
# Stub version of: \\E(B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[0J$<300>' => '
#
# Stub version of: \\E[0J$<300>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E=%p1%{32}%+%c%{32}%c\\E#1\\E=%p2%{32}%+%c%{32}%c\\E#2' => '
#
# Stub version of: \\E=%p1%{32}%+%c%{32}%c\\E#1\\E=%p2%{32}%+%c%{32}%c\\E#2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, 32); # %{32}
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, 32); # %{32}
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\EFb' => '
#
# Stub version of: \\EFb
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E[m\\s' => '
#
# Stub version of: \\E[m\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\EH\\003\\EcB0' => '
#
# Stub version of: \\EH\\003\\EcB0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(66); # B
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E(K' => '
#
# Stub version of: \\E(K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E[1v' => '
#
# Stub version of: \\E[1v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(118); # v

  return $rc;
}
',
          '^W' => '
#
# Stub version of: ^W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^W

  return $rc;
}
',
          '\\E[0%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;m' => '
#
# Stub version of: \\E[0%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E(0$<2>' => '
#
# Stub version of: \\E(0$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[>1;4A' => '
#
# Stub version of: \\E[>1;4A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[8ZZ' => '
#
# Stub version of: \\E[8ZZ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(90); # Z
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\E[?5l\\E[48*|\\E[48t\\E[40l\\E[1;48r\\E[132$|' => '
#
# Stub version of: \\E[?5l\\E[48*|\\E[48t\\E[40l\\E[1;48r\\E[132$|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(42); # *
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(116); # t
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\EK\\032$<50>\\E(\\Ek\\010\\Em\\010\\Eq\\032$<50>' => '
#
# Stub version of: \\EK\\032$<50>\\E(\\Ek\\010\\Em\\010\\Eq\\032$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(26); # \\032
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(26); # \\032
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0$}' => '
#
# Stub version of: \\E[0$}
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(125); # }

  return $rc;
}
',
          '^NG' => '
#
# Stub version of: ^NG
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^N
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\23344~' => '
#
# Stub version of: \\23344~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[4h$<6>' => '
#
# Stub version of: \\E[4h$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\0l' => '
#
# Stub version of: \\0l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E/' => '
#
# Stub version of: \\E/
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(47); # /

  return $rc;
}
',
          '\\027%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\027%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(23); # \\027
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\233011z' => '
#
# Stub version of: \\233011z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\n$<4>' => '
#
# Stub version of: \\n$<4>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1;4A' => '
#
# Stub version of: \\E[1;4A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(65); # A

  return $rc;
}
',
          '^P\\0^W' => '
#
# Stub version of: ^P\\0^W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(128); # \\0
  $rc .= chr(0); # ^W

  return $rc;
}
',
          '\\E[S' => '
#
# Stub version of: \\E[S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\036RF4831\\:\\036RF2>31;\\036RF1=31<\\036RF3?31=' => '
#
# Stub version of: \\036RF4831\\:\\036RF2>31;\\036RF1=31<\\036RF3?31=
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\:
  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(70); # F
  $rc .= chr(50); # 2
  $rc .= chr(62); # >
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(61); # =
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(60); # <
  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(70); # F
  $rc .= chr(51); # 3
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(61); # =

  return $rc;
}
',
          '\\0\\214' => '
#
# Stub version of: \\0\\214
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(140); # \\214

  return $rc;
}
',
          '\\E+$<160>' => '
#
# Stub version of: \\E+$<160>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0%?%p5%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p1%p3%|%p4%|%t;7%;m' => '
#
# Stub version of: \\E[0%?%p5%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p1%p3%|%p4%|%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[3]); # %p4
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[20\\^' => '
#
# Stub version of: \\E[20\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\Eg\\Ef' => '
#
# Stub version of: \\Eg\\Ef
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\EF2\\EG0\\E\\\\L' => '
#
# Stub version of: \\EF2\\EG0\\E\\\\L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\EsR' => '
#
# Stub version of: \\EsR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\ET$<5>' => '
#
# Stub version of: \\ET$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1K$<12>' => '
#
# Stub version of: \\E[1K$<12>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '+/\\,.-\\230.\\2310[5566778899\\:\\:;;<<==>>FFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXX`\\204a0fxgqh2jYk?lZm@nEqDtCu4vAwBx3yszr{c}\\034~\\207' => '
#
# Stub version of: +/\\,.-\\230.\\2310[5566778899\\:\\:;;<<==>>FFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXX`\\204a0fxgqh2jYk?lZm@nEqDtCu4vAwBx3yszr{c}\\034~\\207
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(47); # /
  $rc .= chr(128); # \\,
  $rc .= chr(46); # .
  $rc .= chr(45); # -
  $rc .= chr(152); # \\230
  $rc .= chr(46); # .
  $rc .= chr(153); # \\231
  $rc .= chr(48); # 0
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(55); # 7
  $rc .= chr(55); # 7
  $rc .= chr(56); # 8
  $rc .= chr(56); # 8
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\:
  $rc .= chr(128); # \\:
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(60); # <
  $rc .= chr(61); # =
  $rc .= chr(61); # =
  $rc .= chr(62); # >
  $rc .= chr(62); # >
  $rc .= chr(70); # F
  $rc .= chr(70); # F
  $rc .= chr(71); # G
  $rc .= chr(71); # G
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(73); # I
  $rc .= chr(73); # I
  $rc .= chr(74); # J
  $rc .= chr(74); # J
  $rc .= chr(75); # K
  $rc .= chr(75); # K
  $rc .= chr(76); # L
  $rc .= chr(76); # L
  $rc .= chr(77); # M
  $rc .= chr(77); # M
  $rc .= chr(78); # N
  $rc .= chr(78); # N
  $rc .= chr(79); # O
  $rc .= chr(79); # O
  $rc .= chr(80); # P
  $rc .= chr(80); # P
  $rc .= chr(81); # Q
  $rc .= chr(81); # Q
  $rc .= chr(82); # R
  $rc .= chr(82); # R
  $rc .= chr(83); # S
  $rc .= chr(83); # S
  $rc .= chr(84); # T
  $rc .= chr(84); # T
  $rc .= chr(85); # U
  $rc .= chr(85); # U
  $rc .= chr(86); # V
  $rc .= chr(86); # V
  $rc .= chr(87); # W
  $rc .= chr(87); # W
  $rc .= chr(88); # X
  $rc .= chr(88); # X
  $rc .= chr(96); # `
  $rc .= chr(132); # \\204
  $rc .= chr(97); # a
  $rc .= chr(48); # 0
  $rc .= chr(102); # f
  $rc .= chr(120); # x
  $rc .= chr(103); # g
  $rc .= chr(113); # q
  $rc .= chr(104); # h
  $rc .= chr(50); # 2
  $rc .= chr(106); # j
  $rc .= chr(89); # Y
  $rc .= chr(107); # k
  $rc .= chr(63); # ?
  $rc .= chr(108); # l
  $rc .= chr(90); # Z
  $rc .= chr(109); # m
  $rc .= chr(64); # @
  $rc .= chr(110); # n
  $rc .= chr(69); # E
  $rc .= chr(113); # q
  $rc .= chr(68); # D
  $rc .= chr(116); # t
  $rc .= chr(67); # C
  $rc .= chr(117); # u
  $rc .= chr(52); # 4
  $rc .= chr(118); # v
  $rc .= chr(65); # A
  $rc .= chr(119); # w
  $rc .= chr(66); # B
  $rc .= chr(120); # x
  $rc .= chr(51); # 3
  $rc .= chr(121); # y
  $rc .= chr(115); # s
  $rc .= chr(122); # z
  $rc .= chr(114); # r
  $rc .= chr(123); # {
  $rc .= chr(99); # c
  $rc .= chr(125); # }
  $rc .= chr(28); # \\034
  $rc .= chr(126); # ~
  $rc .= chr(135); # \\207

  return $rc;
}
',
          '\\E[33m' => '
#
# Stub version of: \\E[33m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\013\\035ili;' => '
#
# Stub version of: \\013\\035ili;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  $rc .= chr(29); # \\035
  $rc .= chr(105); # i
  $rc .= chr(108); # l
  $rc .= chr(105); # i
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\007$<100/>' => '
#
# Stub version of: \\007$<100/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(7); # \\007
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[A$<5>' => '
#
# Stub version of: \\E[A$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '%p1%{8}%/%{6}%*%{3}%+\\E[%d%p1%{8}%m%Pa%?%ga%{1}%=%t4%e%ga%{3}%=%t6%e%ga%{4}%=%t1%e%ga%{6}%=%t3%e%ga%d%;m' => '
#
# Stub version of: %p1%{8}%/%{6}%*%{3}%+\\E[%d%p1%{8}%m%Pa%?%ga%{1}%=%t4%e%ga%{3}%=%t6%e%ga%{4}%=%t1%e%ga%{6}%=%t3%e%ga%d%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  push(@iparam, $param[0]); # %p1
  push(@iparam, 8); # %{8}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 6); # %{6}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 3); # %{3}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  push(@iparam, $param[0]); # %p1
  push(@iparam, 8); # %{8}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  $dynamicp->[0] = pop(@iparam); # %Pa
  if (do { # %?
           push(@iparam, $dynamicp->[0]); # %ga
           push(@iparam, 1); # %{1}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $dynamicp->[0]); # %ga
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
  }
  else { # %e
    push(@iparam, $dynamicp->[0]); # %ga
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[2;0;1;0v\\E(0\\017' => '
#
# Stub version of: \\E[2;0;1;0v\\E(0\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(48); # 0
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '^S\\E' => '
#
# Stub version of: ^S\\E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^S
  $rc .= chr(27); # \\E

  return $rc;
}
',
          '\\Ev\\E_AX\\Eb\\EW\\E9P\\ET' => '
#
# Stub version of: \\Ev\\E_AX\\Eb\\EW\\E9P\\ET
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(65); # A
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9
  $rc .= chr(80); # P
  $rc .= chr(27); # \\E
  $rc .= chr(84); # T

  return $rc;
}
',
          'cursor tab' => '
#
# Stub version of: cursor tab
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(99); # c
  $rc .= chr(117); # u
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(111); # o
  $rc .= chr(114); # r
  $rc .= chr(32); #  
  $rc .= chr(116); # t
  $rc .= chr(97); # a
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E(B\\E)0' => '
#
# Stub version of: \\E(B\\E)0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\EO2A' => '
#
# Stub version of: \\EO2A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(50); # 2
  $rc .= chr(65); # A

  return $rc;
}
',
          '~^Z' => '
#
# Stub version of: ~^Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(0); # ^Z

  return $rc;
}
',
          'f7' => '
#
# Stub version of: f7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(102); # f
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\Eb\\E[m\\017\\E[?7h\\E[H\\E[J' => '
#
# Stub version of: \\Eb\\E[m\\017\\E[?7h\\E[H\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[18;3~' => '
#
# Stub version of: \\E[18;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~' => '
#
# Stub version of: ``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(105); # i
  $rc .= chr(105); # i
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(121); # y
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(123); # {
  $rc .= chr(123); # {
  $rc .= chr(124); # |
  $rc .= chr(124); # |
  $rc .= chr(125); # }
  $rc .= chr(125); # }
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E*$<2>' => '
#
# Stub version of: \\E*$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '^\\' => '
#
# Stub version of: ^\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '%?%gH%{0}%=%t\\E&dH%{1}%PH%;' => '
#
# Stub version of: %?%gH%{0}%=%t\\E&dH%{1}%PH%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $staticp->[7]); # %gH
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(100); # d
    $rc .= chr(72); # H
    push(@iparam, 1); # %{1}
    $staticp->[7] = pop(@iparam); # %PH
  } # %;

  return $rc;
}
',
          '\\E[14\\^' => '
#
# Stub version of: \\E[14\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\Es8' => '
#
# Stub version of: \\Es8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\EK1$<200>\\EK0' => '
#
# Stub version of: \\EK1$<200>\\EK0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[1;5H' => '
#
# Stub version of: \\E[1;5H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E4!a' => '
#
# Stub version of: \\E4!a
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(33); # !
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\E[61;%p1%dw' => '
#
# Stub version of: \\E[61;%p1%dw
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\002%p2%{32}%+%c%p1%{32}%+%c$<2/>' => '
#
# Stub version of: \\002%p2%{32}%+%c%p1%{32}%+%c$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(2); # \\002
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          'jEkTl\\\\mMqLxU' => '
#
# Stub version of: jEkTl\\\\mMqLxU
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(106); # j
  $rc .= chr(69); # E
  $rc .= chr(107); # k
  $rc .= chr(84); # T
  $rc .= chr(108); # l
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(109); # m
  $rc .= chr(77); # M
  $rc .= chr(113); # q
  $rc .= chr(76); # L
  $rc .= chr(120); # x
  $rc .= chr(85); # U

  return $rc;
}
',
          '\\017\\E[0m$<120>' => '
#
# Stub version of: \\017\\E[0m$<120>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E!\\r' => '
#
# Stub version of: \\E!\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\030$<30/>' => '
#
# Stub version of: \\030$<30/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(24); # \\030
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '^B6^J' => '
#
# Stub version of: ^B6^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(54); # 6
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '\\E[>52l' => '
#
# Stub version of: \\E[>52l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(50); # 2
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\001P0\\001O1\\001R1\\001C4\\,\\001c0\\,\\014\\001M0\\,42\\,WARNING DOUBLE ENTER ESCAPE and \\025\\001C1\\,\\001c2\\,\\001W0\\,0\\,79\\,39\\,' => '
#
# Stub version of: \\001P0\\001O1\\001R1\\001C4\\,\\001c0\\,\\014\\001M0\\,42\\,WARNING DOUBLE ENTER ESCAPE and \\025\\001C1\\,\\001c2\\,\\001W0\\,0\\,79\\,39\\,
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(1); # \\001
  $rc .= chr(80); # P
  $rc .= chr(48); # 0
  $rc .= chr(1); # \\001
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(1); # \\001
  $rc .= chr(82); # R
  $rc .= chr(49); # 1
  $rc .= chr(1); # \\001
  $rc .= chr(67); # C
  $rc .= chr(52); # 4
  $rc .= chr(128); # \\,
  $rc .= chr(1); # \\001
  $rc .= chr(99); # c
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(12); # \\014
  $rc .= chr(1); # \\001
  $rc .= chr(77); # M
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\,
  $rc .= chr(87); # W
  $rc .= chr(65); # A
  $rc .= chr(82); # R
  $rc .= chr(78); # N
  $rc .= chr(73); # I
  $rc .= chr(78); # N
  $rc .= chr(71); # G
  $rc .= chr(32); #  
  $rc .= chr(68); # D
  $rc .= chr(79); # O
  $rc .= chr(85); # U
  $rc .= chr(66); # B
  $rc .= chr(76); # L
  $rc .= chr(69); # E
  $rc .= chr(32); #  
  $rc .= chr(69); # E
  $rc .= chr(78); # N
  $rc .= chr(84); # T
  $rc .= chr(69); # E
  $rc .= chr(82); # R
  $rc .= chr(32); #  
  $rc .= chr(69); # E
  $rc .= chr(83); # S
  $rc .= chr(67); # C
  $rc .= chr(65); # A
  $rc .= chr(80); # P
  $rc .= chr(69); # E
  $rc .= chr(32); #  
  $rc .= chr(97); # a
  $rc .= chr(110); # n
  $rc .= chr(100); # d
  $rc .= chr(32); #  
  $rc .= chr(21); # \\025
  $rc .= chr(1); # \\001
  $rc .= chr(67); # C
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\,
  $rc .= chr(1); # \\001
  $rc .= chr(99); # c
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\,
  $rc .= chr(1); # \\001
  $rc .= chr(87); # W
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(55); # 7
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\,
  $rc .= chr(51); # 3
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\,

  return $rc;
}
',
          '\\E[21;1j\\E[25;4j\\Eent\\E~' => '
#
# Stub version of: \\E[21;1j\\E[25;4j\\Eent\\E~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(110); # n
  $rc .= chr(116); # t
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E1;2f' => '
#
# Stub version of: \\E1;2f
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\Eq' => '
#
# Stub version of: \\Eq
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E0Q\\016' => '
#
# Stub version of: \\E0Q\\016
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(81); # Q
  $rc .= chr(14); # \\016

  return $rc;
}
',
          '\\E[D$<5>' => '
#
# Stub version of: \\E[D$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(68); # D
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ed$<200>\\Eb' => '
#
# Stub version of: \\Ed$<200>\\Eb
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\EY%p1%{32}%+%c%p2%{32}%+%c$<5/>' => '
#
# Stub version of: \\EY%p1%{32}%+%c%p2%{32}%+%c$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[18' => '
#
# Stub version of: \\E[18
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\EM$<2*>' => '
#
# Stub version of: \\EM$<2*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\23324~' => '
#
# Stub version of: \\23324~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^B0\\r' => '
#
# Stub version of: ^B0\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(48); # 0
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EOK' => '
#
# Stub version of: \\EOK
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(75); # K

  return $rc;
}
',
          '~$<\\23319>' => '
#
# Stub version of: ~$<\\23319>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E^W' => '
#
# Stub version of: \\E^W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^W

  return $rc;
}
',
          'pf3' => '
#
# Stub version of: pf3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(112); # p
  $rc .= chr(102); # f
  $rc .= chr(51); # 3

  return $rc;
}
',
          '^An\\r' => '
#
# Stub version of: ^An\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(110); # n
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E\\014\\E\\016%p1%\'\\0\'%+%c%p2%\'\\0\'%+%c%p3%\'\\0\'%+%c%p4%\'\\0\'%+%c\\025' => '
#
# Stub version of: \\E\\014\\E\\016%p1%\'\\0\'%+%c%p2%\'\\0\'%+%c%p3%\'\\0\'%+%c%p4%\'\\0\'%+%c\\025
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(12); # \\014
  $rc .= chr(27); # \\E
  $rc .= chr(14); # \\016
  push(@iparam, $param[0]); # %p1
  push(@iparam, chr(128)); # %\'\\0\'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, chr(128)); # %\'\\0\'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[2]); # %p3
  push(@iparam, chr(128)); # %\'\\0\'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[3]); # %p4
  push(@iparam, chr(128)); # %\'\\0\'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(21); # \\025

  return $rc;
}
',
          'U4 PC-DOS Public Domain NANSI.SYS with keypad redefined for vi 9-29-86\\n\\E[;75;8p' => '
#
# Stub version of: U4 PC-DOS Public Domain NANSI.SYS with keypad redefined for vi 9-29-86\\n\\E[;75;8p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(85); # U
  $rc .= chr(52); # 4
  $rc .= chr(32); #  
  $rc .= chr(80); # P
  $rc .= chr(67); # C
  $rc .= chr(45); # -
  $rc .= chr(68); # D
  $rc .= chr(79); # O
  $rc .= chr(83); # S
  $rc .= chr(32); #  
  $rc .= chr(80); # P
  $rc .= chr(117); # u
  $rc .= chr(98); # b
  $rc .= chr(108); # l
  $rc .= chr(105); # i
  $rc .= chr(99); # c
  $rc .= chr(32); #  
  $rc .= chr(68); # D
  $rc .= chr(111); # o
  $rc .= chr(109); # m
  $rc .= chr(97); # a
  $rc .= chr(105); # i
  $rc .= chr(110); # n
  $rc .= chr(32); #  
  $rc .= chr(78); # N
  $rc .= chr(65); # A
  $rc .= chr(78); # N
  $rc .= chr(83); # S
  $rc .= chr(73); # I
  $rc .= chr(46); # .
  $rc .= chr(83); # S
  $rc .= chr(89); # Y
  $rc .= chr(83); # S
  $rc .= chr(32); #  
  $rc .= chr(119); # w
  $rc .= chr(105); # i
  $rc .= chr(116); # t
  $rc .= chr(104); # h
  $rc .= chr(32); #  
  $rc .= chr(107); # k
  $rc .= chr(101); # e
  $rc .= chr(121); # y
  $rc .= chr(112); # p
  $rc .= chr(97); # a
  $rc .= chr(100); # d
  $rc .= chr(32); #  
  $rc .= chr(114); # r
  $rc .= chr(101); # e
  $rc .= chr(100); # d
  $rc .= chr(101); # e
  $rc .= chr(102); # f
  $rc .= chr(105); # i
  $rc .= chr(110); # n
  $rc .= chr(101); # e
  $rc .= chr(100); # d
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(111); # o
  $rc .= chr(114); # r
  $rc .= chr(32); #  
  $rc .= chr(118); # v
  $rc .= chr(105); # i
  $rc .= chr(32); #  
  $rc .= chr(57); # 9
  $rc .= chr(45); # -
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(45); # -
  $rc .= chr(56); # 8
  $rc .= chr(54); # 6
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\027$<80>' => '
#
# Stub version of: \\027$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(23); # \\027
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1;2B' => '
#
# Stub version of: \\E[1;2B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[4%p1%dm' => '
#
# Stub version of: \\E[4%p1%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[S\\E[B' => '
#
# Stub version of: \\E[S\\E[B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(83); # S
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(66); # B

  return $rc;
}
',
          'aaffggjjkkllmmnnooqqssttuuvvwwxx~~' => '
#
# Stub version of: aaffggjjkkllmmnnooqqssttuuvvwwxx~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\0e' => '
#
# Stub version of: \\0e
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\E\\:c' => '
#
# Stub version of: \\E\\:c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\:
  $rc .= chr(99); # c

  return $rc;
}
',
          '^V$\\,' => '
#
# Stub version of: ^V$\\,
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(36); # $
  $rc .= chr(128); # \\,

  return $rc;
}
',
          '\\E[13~' => '
#
# Stub version of: \\E[13~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[0n' => '
#
# Stub version of: \\E[0n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\E]2;\\007' => '
#
# Stub version of: \\E]2;\\007
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(7); # \\007

  return $rc;
}
',
          '\\377\\265' => '
#
# Stub version of: \\377\\265
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(181); # \\265

  return $rc;
}
',
          '\\E[>1;7D' => '
#
# Stub version of: \\E[>1;7D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[0p\\017' => '
#
# Stub version of: \\E[0p\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\037ich\\r \\010' => '
#
# Stub version of: \\037ich\\r \\010
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(105); # i
  $rc .= chr(99); # c
  $rc .= chr(104); # h
  $rc .= chr(13); # \\r
  $rc .= chr(32); #  
  $rc .= chr(8); # \\010

  return $rc;
}
',
          '\\E(009\\,017\\,025\\,033\\,041\\,049\\,057\\,065\\,073\\,081\\,089\\,097\\,105\\,113\\,121\\,129.' => '
#
# Stub version of: \\E(009\\,017\\,025\\,033\\,041\\,049\\,057\\,065\\,073\\,081\\,089\\,097\\,105\\,113\\,121\\,129.
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(55); # 7
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(55); # 7
  $rc .= chr(128); # \\,
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\,
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\,
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\,
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(46); # .

  return $rc;
}
',
          '\\E?c' => '
#
# Stub version of: \\E?c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E[' => '
#
# Stub version of: \\E[
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [

  return $rc;
}
',
          '\\E[24;3~' => '
#
# Stub version of: \\E[24;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E=' => '
#
# Stub version of: \\E=
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =

  return $rc;
}
',
          '\\E[m\\E[?7h\\E[4l\\E>\\E7\\E[r\\E[?1;3;4;6l\\E8' => '
#
# Stub version of: \\E[m\\E[?7h\\E[4l\\E>\\E7\\E[r\\E[?1;3;4;6l\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E40a' => '
#
# Stub version of: \\E40a
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\377\\315' => '
#
# Stub version of: \\377\\315
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(205); # \\315

  return $rc;
}
',
          '\\E]112\\007' => '
#
# Stub version of: \\E]112\\007
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(7); # \\007

  return $rc;
}
',
          '\\E4A' => '
#
# Stub version of: \\E4A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E$R' => '
#
# Stub version of: \\E$R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(82); # R

  return $rc;
}
',
          '^VC\\r' => '
#
# Stub version of: ^VC\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(67); # C
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^Kp^R' => '
#
# Stub version of: ^Kp^R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^K
  $rc .= chr(112); # p
  $rc .= chr(0); # ^R

  return $rc;
}
',
          '\\E[214z' => '
#
# Stub version of: \\E[214z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[206z' => '
#
# Stub version of: \\E[206z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[31;47m' => '
#
# Stub version of: \\E[31;47m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[23;5~' => '
#
# Stub version of: \\E[23;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[?25h\\E[34l' => '
#
# Stub version of: \\E[?25h\\E[34l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EH\\E&p4dF' => '
#
# Stub version of: \\EH\\E&p4dF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(112); # p
  $rc .= chr(52); # 4
  $rc .= chr(100); # d
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\035dch %p1%d;' => '
#
# Stub version of: \\035dch %p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(100); # d
  $rc .= chr(99); # c
  $rc .= chr(104); # h
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          'PF4' => '
#
# Stub version of: PF4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(80); # P
  $rc .= chr(70); # F
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\Ef\\ED' => '
#
# Stub version of: \\Ef\\ED
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(27); # \\E
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[=119l' => '
#
# Stub version of: \\E[=119l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\246' => '
#
# Stub version of: \\246
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(166); # \\246

  return $rc;
}
',
          '\\EO1;6B' => '
#
# Stub version of: \\EO1;6B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[227z' => '
#
# Stub version of: \\E[227z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\Ex4' => '
#
# Stub version of: \\Ex4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\E(' => '
#
# Stub version of: \\E(
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (

  return $rc;
}
',
          '\\E[K$<2>' => '
#
# Stub version of: \\E[K$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EP$<7>' => '
#
# Stub version of: \\EP$<7>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%p1%dt' => '
#
# Stub version of: \\E[%p1%dt
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\EDL' => '
#
# Stub version of: \\EDL
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\E[4D' => '
#
# Stub version of: \\E[4D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[3~' => '
#
# Stub version of: \\E[3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\014$<8>' => '
#
# Stub version of: \\014$<8>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[m\\E[?7h' => '
#
# Stub version of: \\E[m\\E[?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[?19h' => '
#
# Stub version of: \\E[?19h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[0;36;40m' => '
#
# Stub version of: \\E[0;36;40m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EGc\\EGb\\EGw' => '
#
# Stub version of: \\EGc\\EGb\\EGw
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\E[19;3~' => '
#
# Stub version of: \\E[19;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[14r' => '
#
# Stub version of: \\E[14r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[2;4;20;30l\\E[?1;4;10;16l\\E[12h\\E[?7;8;25h' => '
#
# Stub version of: \\E[2;4;20;30l\\E[?1;4;10;16l\\E[12h\\E[?7;8;25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[V\\E8' => '
#
# Stub version of: \\E[V\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(86); # V
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E=%p1%{32}%+%c%p2%{32}%+%c$<30>' => '
#
# Stub version of: \\E=%p1%{32}%+%c%p2%{32}%+%c$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\233002z' => '
#
# Stub version of: \\233002z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\036Fz2\\036F}00\\036FB180000\\036F}01' => '
#
# Stub version of: \\036Fz2\\036F}00\\036FB180000\\036F}01
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(122); # z
  $rc .= chr(50); # 2
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(125); # }
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(66); # B
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(125); # }
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[0t' => '
#
# Stub version of: \\E[0t
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\E[>?6h' => '
#
# Stub version of: \\E[>?6h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[%p1%dL$<3*>' => '
#
# Stub version of: \\E[%p1%dL$<3*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[010q' => '
#
# Stub version of: \\E[010q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[16~' => '
#
# Stub version of: \\E[16~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EO5S' => '
#
# Stub version of: \\EO5S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(53); # 5
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E[7;5~' => '
#
# Stub version of: \\E[7;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\Ez$<4/>' => '
#
# Stub version of: \\Ez$<4/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\2331B' => '
#
# Stub version of: \\2331B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\EM \\EF\\ET\\EP\\ER 7' => '
#
# Stub version of: \\EM \\EF\\ET\\EP\\ER 7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(32); #  
  $rc .= chr(55); # 7

  return $rc;
}
',
          '^^^Rl' => '
#
# Stub version of: ^^^Rl
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(0); # ^R
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EZ1%p1%{63}%+%c%p2%s\\177' => '
#
# Stub version of: \\EZ1%p1%{63}%+%c%p2%s\\177
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(90); # Z
  $rc .= chr(49); # 1
  push(@iparam, $param[0]); # %p1
  push(@iparam, 63); # %{63}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(127); # \\177

  return $rc;
}
',
          '^^z' => '
#
# Stub version of: ^^z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[4%p1%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m' => '
#
# Stub version of: \\E[4%p1%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  if (do { # %?
           push(@iparam, $staticp->[3]); # %gD
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[20]); # %gU
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[1]); # %gB
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[17]); # %gR
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[&p\\E[<12l\\E F\\E[<14h' => '
#
# Stub version of: \\E[&p\\E[<12l\\E F\\E[<14h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(38); # &
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EG0\\E s\\017\\E~' => '
#
# Stub version of: \\EG0\\E s\\017\\E~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(115); # s
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E>\\E[?3h\\E[?4l\\E[?5l\\E[?8h' => '
#
# Stub version of: \\E>\\E[?3h\\E[?4l\\E[?5l\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\Er\\E[W\\E`' => '
#
# Stub version of: \\Er\\E[W\\E`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(87); # W
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `

  return $rc;
}
',
          '^AN\\r' => '
#
# Stub version of: ^AN\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(78); # N
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^Nt' => '
#
# Stub version of: ^Nt
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^N
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\E[>1;2D' => '
#
# Stub version of: \\E[>1;2D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E/>6h' => '
#
# Stub version of: \\E/>6h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(54); # 6
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[%p1%dT\\E[%p1%dA' => '
#
# Stub version of: \\E[%p1%dT\\E[%p1%dA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(84); # T
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\ENN' => '
#
# Stub version of: \\ENN
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(78); # N

  return $rc;
}
',
          '\\E60' => '
#
# Stub version of: \\E60
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0

  return $rc;
}
',
          '^Af\\r' => '
#
# Stub version of: ^Af\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(102); # f
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '``aajjkkllmmnnooppqqrrssttuuvvwwxx~~' => '
#
# Stub version of: ``aajjkkllmmnnooppqqrrssttuuvvwwxx~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\377\\377\\030\\035$<10>' => '
#
# Stub version of: \\377\\377\\030\\035$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(255); # \\377
  $rc .= chr(24); # \\030
  $rc .= chr(29); # \\035
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?3l kbs=\\010' => '
#
# Stub version of: \\E[?3l kbs=\\010
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(32); #  
  $rc .= chr(107); # k
  $rc .= chr(98); # b
  $rc .= chr(115); # s
  $rc .= chr(61); # =
  $rc .= chr(8); # \\010

  return $rc;
}
',
          '\\E[13;5~' => '
#
# Stub version of: \\E[13;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E\\023\\E5' => '
#
# Stub version of: \\E\\023\\E5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  $rc .= chr(27); # \\E
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\Ed@' => '
#
# Stub version of: \\Ed@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\EN|' => '
#
# Stub version of: \\EN|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\E6' => '
#
# Stub version of: \\E6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\Ev    $<6>\\Ep\\r\\n' => '
#
# Stub version of: \\Ev    $<6>\\Ep\\r\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '^\\031\\r' => '
#
# Stub version of: ^\\031\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(25); # \\031
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\013$<16*/>' => '
#
# Stub version of: \\013$<16*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\036RG0%p1%{16}%/%{48}%+%c%p1%{16}%m%{48}%+%c%p2%{255}%*%{1000}%/%Pa%ga%{16}%/%{48}%+%c%ga%{16}%m%{48}%+%c%p3%{255}%*%{1000}%/%Pa%ga%{16}%/%{48}%+%c%ga%{16}%m%{48}%+%c%p4%{255}%*%{1000}%/%Pa%ga%{16}%/%{48}%+%c%ga%{16}%m%{48}%+%c%p5%{255}%*%{1000}%/%Pa%ga%{16}%/%{48}%+%c%ga%{16}%m%{48}%+%c%p6%{255}%*%{1000}%/%Pa%ga%{16}%/%{48}%+%c%ga%{16}%m%{48}%+%c%p7%{255}%*%{1000}%/%Pa%ga%{16}%/%{48}%+%c%ga%{16}%m%{48}%+%c' => '
#
# Stub version of: \\036RG0%p1%{16}%/%{48}%+%c%p1%{16}%m%{48}%+%c%p2%{255}%*%{1000}%/%Pa%ga%{16}%/%{48}%+%c%ga%{16}%m%{48}%+%c%p3%{255}%*%{1000}%/%Pa%ga%{16}%/%{48}%+%c%ga%{16}%m%{48}%+%c%p4%{255}%*%{1000}%/%Pa%ga%{16}%/%{48}%+%c%ga%{16}%m%{48}%+%c%p5%{255}%*%{1000}%/%Pa%ga%{16}%/%{48}%+%c%ga%{16}%m%{48}%+%c%p6%{255}%*%{1000}%/%Pa%ga%{16}%/%{48}%+%c%ga%{16}%m%{48}%+%c%p7%{255}%*%{1000}%/%Pa%ga%{16}%/%{48}%+%c%ga%{16}%m%{48}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  push(@iparam, $param[0]); # %p1
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $dynamicp->[0] = pop(@iparam); # %Pa
  push(@iparam, $dynamicp->[0]); # %ga
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[0]); # %ga
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[2]); # %p3
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $dynamicp->[0] = pop(@iparam); # %Pa
  push(@iparam, $dynamicp->[0]); # %ga
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[0]); # %ga
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[3]); # %p4
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $dynamicp->[0] = pop(@iparam); # %Pa
  push(@iparam, $dynamicp->[0]); # %ga
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[0]); # %ga
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[4]); # %p5
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $dynamicp->[0] = pop(@iparam); # %Pa
  push(@iparam, $dynamicp->[0]); # %ga
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[0]); # %ga
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[5]); # %p6
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $dynamicp->[0] = pop(@iparam); # %Pa
  push(@iparam, $dynamicp->[0]); # %ga
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[0]); # %ga
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[6]); # %p7
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $dynamicp->[0] = pop(@iparam); # %Pa
  push(@iparam, $dynamicp->[0]); # %ga
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[0]); # %ga
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\217s' => '
#
# Stub version of: \\217s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E0Q\\E)' => '
#
# Stub version of: \\E0Q\\E)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )

  return $rc;
}
',
          '\\2333g' => '
#
# Stub version of: \\2333g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\E\\025$<16>' => '
#
# Stub version of: \\E\\025$<16>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(21); # \\025
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EOr' => '
#
# Stub version of: \\EOr
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\017$<20>' => '
#
# Stub version of: \\017$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[00\\:z' => '
#
# Stub version of: \\E[00\\:z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\:
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\377\\221' => '
#
# Stub version of: \\377\\221
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(145); # \\221

  return $rc;
}
',
          '\\E`\\:\\E`9$<30>' => '
#
# Stub version of: \\E`\\:\\E`9$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&d@%{0}%PA%{0}%PB%{0}%PD%{0}%PH%?%p1%p3%p5%|%|%t\\E&dB%{1}%PB%;%?%p4%t\\E&dA%{1}%PA%;%?%p6%t\\E&dH%{1}%PH%;%?%p2%t\\E&dD%;' => '
#
# Stub version of: \\E&d@%{0}%PA%{0}%PB%{0}%PD%{0}%PH%?%p1%p3%p5%|%|%t\\E&dB%{1}%PB%;%?%p4%t\\E&dA%{1}%PA%;%?%p6%t\\E&dH%{1}%PH%;%?%p2%t\\E&dD%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(64); # @
  push(@iparam, 0); # %{0}
  $staticp->[0] = pop(@iparam); # %PA
  push(@iparam, 0); # %{0}
  $staticp->[1] = pop(@iparam); # %PB
  push(@iparam, 0); # %{0}
  $staticp->[3] = pop(@iparam); # %PD
  push(@iparam, 0); # %{0}
  $staticp->[7] = pop(@iparam); # %PH
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(100); # d
    $rc .= chr(66); # B
    push(@iparam, 1); # %{1}
    $staticp->[1] = pop(@iparam); # %PB
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(100); # d
    $rc .= chr(65); # A
    push(@iparam, 1); # %{1}
    $staticp->[0] = pop(@iparam); # %PA
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(100); # d
    $rc .= chr(72); # H
    push(@iparam, 1); # %{1}
    $staticp->[7] = pop(@iparam); # %PH
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(100); # d
    $rc .= chr(68); # D
  } # %;

  return $rc;
}
',
          '\\EO6A' => '
#
# Stub version of: \\EO6A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(54); # 6
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[?E\\E[?%i%p1%dT' => '
#
# Stub version of: \\E[?E\\E[?%i%p1%dT
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\E[=5;<2m' => '
#
# Stub version of: \\E[=5;<2m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[42h' => '
#
# Stub version of: \\E[42h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[=3l\\EF1\\Ed\\EG0\\E[=5l\\E%\\El' => '
#
# Stub version of: \\E[=3l\\EF1\\Ed\\EG0\\E[=5l\\E%\\El
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\Ef%p2%{32}%+%c%p1%{32}%+%c' => '
#
# Stub version of: \\Ef%p2%{32}%+%c%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          'A delete line' => '
#
# Stub version of: A delete line
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(65); # A
  $rc .= chr(32); #  
  $rc .= chr(100); # d
  $rc .= chr(101); # e
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(116); # t
  $rc .= chr(101); # e
  $rc .= chr(32); #  
  $rc .= chr(108); # l
  $rc .= chr(105); # i
  $rc .= chr(110); # n
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\EOU' => '
#
# Stub version of: \\EOU
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(85); # U

  return $rc;
}
',
          '^CH' => '
#
# Stub version of: ^CH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^C
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\EG0$<10/>' => '
#
# Stub version of: \\EG0$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[>1h\\E[>9l' => '
#
# Stub version of: \\E[>1h\\E[>9l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(57); # 9
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[198z' => '
#
# Stub version of: \\E[198z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[00u\\E[<>001001024132024132u\\E[01u' => '
#
# Stub version of: \\E[00u\\E[<>001001024132024132u\\E[01u
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(62); # >
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(117); # u

  return $rc;
}
',
          'K1 Standard Kermit plus Automatic Margins\\n' => '
#
# Stub version of: K1 Standard Kermit plus Automatic Margins\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(75); # K
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(83); # S
  $rc .= chr(116); # t
  $rc .= chr(97); # a
  $rc .= chr(110); # n
  $rc .= chr(100); # d
  $rc .= chr(97); # a
  $rc .= chr(114); # r
  $rc .= chr(100); # d
  $rc .= chr(32); #  
  $rc .= chr(75); # K
  $rc .= chr(101); # e
  $rc .= chr(114); # r
  $rc .= chr(109); # m
  $rc .= chr(105); # i
  $rc .= chr(116); # t
  $rc .= chr(32); #  
  $rc .= chr(112); # p
  $rc .= chr(108); # l
  $rc .= chr(117); # u
  $rc .= chr(115); # s
  $rc .= chr(32); #  
  $rc .= chr(65); # A
  $rc .= chr(117); # u
  $rc .= chr(116); # t
  $rc .= chr(111); # o
  $rc .= chr(109); # m
  $rc .= chr(97); # a
  $rc .= chr(116); # t
  $rc .= chr(105); # i
  $rc .= chr(99); # c
  $rc .= chr(32); #  
  $rc .= chr(77); # M
  $rc .= chr(97); # a
  $rc .= chr(114); # r
  $rc .= chr(103); # g
  $rc .= chr(105); # i
  $rc .= chr(110); # n
  $rc .= chr(115); # s
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\E|%p1%{48}%+%c1%p2%s\\031' => '
#
# Stub version of: \\E|%p1%{48}%+%c1%p2%s\\031
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(124); # |
  push(@iparam, $param[0]); # %p1
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(49); # 1
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(25); # \\031

  return $rc;
}
',
          '^\\023\\r' => '
#
# Stub version of: ^\\023\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(19); # \\023
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\233304z' => '
#
# Stub version of: \\233304z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\Ez4;2;1z\\Ez56;2;80;30z' => '
#
# Stub version of: \\Ez4;2;1z\\Ez56;2;80;30z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(122); # z
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\ES$<20>' => '
#
# Stub version of: \\ES$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E)0' => '
#
# Stub version of: \\E)0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\EOh' => '
#
# Stub version of: \\EOh
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EFI' => '
#
# Stub version of: \\EFI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\E%p2%d;%p1%dM' => '
#
# Stub version of: \\E%p2%d;%p1%dM
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\E7\\E[2;24r\\E8' => '
#
# Stub version of: \\E7\\E[2;24r\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '~$<\\23317>' => '
#
# Stub version of: ~$<\\23317>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\250' => '
#
# Stub version of: \\377\\250
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(168); # \\250

  return $rc;
}
',
          '\\E&dJ' => '
#
# Stub version of: \\E&dJ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E7\\E[r\\E8\\E[m\\E[?7h\\E[?1;3;4;6l\\E[4l\\E>\\E[?1000l\\E[?25h' => '
#
# Stub version of: \\E7\\E[r\\E8\\E[m\\E[?7h\\E[?1;3;4;6l\\E[4l\\E>\\E[?1000l\\E[?25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EF16' => '
#
# Stub version of: \\EF16
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6

  return $rc;
}
',
          '^^E' => '
#
# Stub version of: ^^E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(69); # E

  return $rc;
}
',
          '^B(\\r' => '
#
# Stub version of: ^B(\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(40); # (
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\377\\342' => '
#
# Stub version of: \\377\\342
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(226); # \\342

  return $rc;
}
',
          '\\E#5' => '
#
# Stub version of: \\E#5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E[s\\E[>5;1h\\E[25;%i%dH\\E[1K' => '
#
# Stub version of: \\E[s\\E[>5;1h\\E[25;%i%dH\\E[1K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\002\\Er\\003' => '
#
# Stub version of: \\002\\Er\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(2); # \\002
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '\\036A%p1%?%p1%{8}%<%t%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%;%{48}%+%c' => '
#
# Stub version of: \\036A%p1%?%p1%{8}%<%t%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%;%{48}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(65); # A
  push(@iparam, $param[0]); # %p1
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 8); # %{8}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
    push(@iparam, pop(@iparam) & pop(@iparam)); # %&
    if (do { # %?
             push(@iparam, $param[0]); # %p1
             push(@iparam, 1); # %{1}
             push(@iparam, pop(@iparam) & pop(@iparam)); # %&
             pop(@iparam);
           }) { # %t
      push(@iparam, 4); # %{4}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
    if (do { # %?
             push(@iparam, $param[0]); # %p1
             push(@iparam, 4); # %{4}
             push(@iparam, pop(@iparam) & pop(@iparam)); # %&
             pop(@iparam);
           }) { # %t
      push(@iparam, 1); # %{1}
      push(@iparam, pop(@iparam) | pop(@iparam)); # %|
    } # %;
  } # %;
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E+$<80>' => '
#
# Stub version of: \\E+$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '61a\\202f\\260g2j\\213k\\214l\\215m\\216n\\217o\\220q\\222s\\224t\\225u\\226v\\227w\\230x\\231~\\244' => '
#
# Stub version of: 61a\\202f\\260g2j\\213k\\214l\\215m\\216n\\217o\\220q\\222s\\224t\\225u\\226v\\227w\\230x\\231~\\244
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(54); # 6
  $rc .= chr(49); # 1
  $rc .= chr(97); # a
  $rc .= chr(130); # \\202
  $rc .= chr(102); # f
  $rc .= chr(176); # \\260
  $rc .= chr(103); # g
  $rc .= chr(50); # 2
  $rc .= chr(106); # j
  $rc .= chr(139); # \\213
  $rc .= chr(107); # k
  $rc .= chr(140); # \\214
  $rc .= chr(108); # l
  $rc .= chr(141); # \\215
  $rc .= chr(109); # m
  $rc .= chr(142); # \\216
  $rc .= chr(110); # n
  $rc .= chr(143); # \\217
  $rc .= chr(111); # o
  $rc .= chr(144); # \\220
  $rc .= chr(113); # q
  $rc .= chr(146); # \\222
  $rc .= chr(115); # s
  $rc .= chr(148); # \\224
  $rc .= chr(116); # t
  $rc .= chr(149); # \\225
  $rc .= chr(117); # u
  $rc .= chr(150); # \\226
  $rc .= chr(118); # v
  $rc .= chr(151); # \\227
  $rc .= chr(119); # w
  $rc .= chr(152); # \\230
  $rc .= chr(120); # x
  $rc .= chr(153); # \\231
  $rc .= chr(126); # ~
  $rc .= chr(164); # \\244

  return $rc;
}
',
          '\\Ew@%p1%{48}%+%c%p2%{32}%+%c%p3%{32}%+%c$<10>' => '
#
# Stub version of: \\Ew@%p1%{48}%+%c%p2%{32}%+%c%p3%{32}%+%c$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(64); # @
  push(@iparam, $param[0]); # %p1
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[2]); # %p3
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '!com 31\\r\\n\\037sto 9 17 25 33 41 49 57 65 73\\r\\037wor 17\\r\\037mon 17\\r' => '
#
# Stub version of: !com 31\\r\\n\\037sto 9 17 25 33 41 49 57 65 73\\r\\037wor 17\\r\\037mon 17\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(33); # !
  $rc .= chr(99); # c
  $rc .= chr(111); # o
  $rc .= chr(109); # m
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(31); # \\037
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(111); # o
  $rc .= chr(32); #  
  $rc .= chr(57); # 9
  $rc .= chr(32); #  
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(32); #  
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(32); #  
  $rc .= chr(53); # 5
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(32); #  
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(13); # \\r
  $rc .= chr(31); # \\037
  $rc .= chr(119); # w
  $rc .= chr(111); # o
  $rc .= chr(114); # r
  $rc .= chr(32); #  
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(13); # \\r
  $rc .= chr(31); # \\037
  $rc .= chr(109); # m
  $rc .= chr(111); # o
  $rc .= chr(110); # n
  $rc .= chr(32); #  
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%p1%dM$<4*>' => '
#
# Stub version of: \\E[%p1%dM$<4*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[H$<2>$<80>' => '
#
# Stub version of: \\E[H$<2>$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[5i' => '
#
# Stub version of: \\E[5i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\ENr' => '
#
# Stub version of: \\ENr
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(114); # r

  return $rc;
}
',
          '~^Q' => '
#
# Stub version of: ~^Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(0); # ^Q

  return $rc;
}
',
          '\\E#@' => '
#
# Stub version of: \\E#@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;m%?%p9%t\\E(0%e\\E(B%;' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;m%?%p9%t\\E(0%e\\E(B%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;

  return $rc;
}
',
          '\\E&f%p1%dk%p2%l%dd0L%p2%s' => '
#
# Stub version of: \\E&f%p1%dk%p2%l%dd0L%p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(102); # f
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(107); # k
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(100); # d
  $rc .= chr(48); # 0
  $rc .= chr(76); # L
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\E^N' => '
#
# Stub version of: \\E^N
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^N

  return $rc;
}
',
          '^\\042\\r' => '
#
# Stub version of: ^\\042\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(34); # \\042
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^^^F' => '
#
# Stub version of: ^^^F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(0); # ^F

  return $rc;
}
',
          '\\EK$<332>' => '
#
# Stub version of: \\EK$<332>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '^Z0' => '
#
# Stub version of: ^Z0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Z
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[0%?%p5%p6%|%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%p6%|%t;7%;%?%p7%t;8%;m%?%p8%t\\EV%;%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p5%p6%|%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%p6%|%t;7%;%?%p7%t;8%;m%?%p8%t\\EV%;%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[0]); # %p1
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[7]); # %p8
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(86); # V
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\E[7A' => '
#
# Stub version of: \\E[7A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\ER' => '
#
# Stub version of: \\ER
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[>13h' => '
#
# Stub version of: \\E[>13h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\Ed#' => '
#
# Stub version of: \\Ed#
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(35); # #

  return $rc;
}
',
          '\\E*$<10>' => '
#
# Stub version of: \\E*$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EFe' => '
#
# Stub version of: \\EFe
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\E[3%p1%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m' => '
#
# Stub version of: \\E[3%p1%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  if (do { # %?
           push(@iparam, $staticp->[3]); # %gD
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[20]); # %gU
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[1]); # %gB
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[17]); # %gR
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7l\\E[?8h\\E[1;24r\\E[24;1H' => '
#
# Stub version of: \\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7l\\E[?8h\\E[1;24r\\E[24;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[29~' => '
#
# Stub version of: \\E[29~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[002z' => '
#
# Stub version of: \\E[002z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '%?%p9%t\\016%e\\017%;B\\E[0%?%p6%t;1%;%?%p2%t;1%;%?%p1%p3%|%t;7%;m' => '
#
# Stub version of: %?%p9%t\\016%e\\017%;B\\E[0%?%p6%t;1%;%?%p2%t;1%;%?%p1%p3%|%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '%?%p1%p5%p8%|%|%t\\E`7\\E)%e\\E(%;%?%p9%t\\EH\\002%e\\EH\\003%;' => '
#
# Stub version of: %?%p1%p5%p8%|%|%t\\E`7\\E)%e\\E(%;%?%p9%t\\EH\\002%e\\EH\\003%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, $param[7]); # %p8
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(96); # `
    $rc .= chr(55); # 7
    $rc .= chr(27); # \\E
    $rc .= chr(41); # )
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(72); # H
    $rc .= chr(2); # \\002
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(72); # H
    $rc .= chr(3); # \\003
  } # %;

  return $rc;
}
',
          '/usr/share/tabset/vt300' => '
#
# Stub version of: /usr/share/tabset/vt300
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(47); # /
  $rc .= chr(117); # u
  $rc .= chr(115); # s
  $rc .= chr(114); # r
  $rc .= chr(47); # /
  $rc .= chr(115); # s
  $rc .= chr(104); # h
  $rc .= chr(97); # a
  $rc .= chr(114); # r
  $rc .= chr(101); # e
  $rc .= chr(47); # /
  $rc .= chr(116); # t
  $rc .= chr(97); # a
  $rc .= chr(98); # b
  $rc .= chr(115); # s
  $rc .= chr(101); # e
  $rc .= chr(116); # t
  $rc .= chr(47); # /
  $rc .= chr(118); # v
  $rc .= chr(116); # t
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '^A^Z' => '
#
# Stub version of: ^A^Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(0); # ^Z

  return $rc;
}
',
          '\\E[232z' => '
#
# Stub version of: \\E[232z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '^H\\EA' => '
#
# Stub version of: ^H\\EA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^H
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\ES%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\ES%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[5A' => '
#
# Stub version of: \\E[5A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[1m' => '
#
# Stub version of: \\E[1m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[?5h$<30/>\\E[?5l' => '
#
# Stub version of: \\E[?5h$<30/>\\E[?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E^G' => '
#
# Stub version of: \\E^G
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^G

  return $rc;
}
',
          '\\EG8' => '
#
# Stub version of: \\EG8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\EO1;4B' => '
#
# Stub version of: \\EO1;4B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E&v0m1a1b0c1i0a1b1c2i1a0b0c0i0S\\E&j@\\r\\E3\\r' => '
#
# Stub version of: \\E&v0m1a1b0c1i0a1b1c2i1a0b0c0i0S\\E&j@\\r\\E3\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(49); # 1
  $rc .= chr(97); # a
  $rc .= chr(49); # 1
  $rc .= chr(98); # b
  $rc .= chr(48); # 0
  $rc .= chr(99); # c
  $rc .= chr(49); # 1
  $rc .= chr(105); # i
  $rc .= chr(48); # 0
  $rc .= chr(97); # a
  $rc .= chr(49); # 1
  $rc .= chr(98); # b
  $rc .= chr(49); # 1
  $rc .= chr(99); # c
  $rc .= chr(50); # 2
  $rc .= chr(105); # i
  $rc .= chr(49); # 1
  $rc .= chr(97); # a
  $rc .= chr(48); # 0
  $rc .= chr(98); # b
  $rc .= chr(48); # 0
  $rc .= chr(99); # c
  $rc .= chr(48); # 0
  $rc .= chr(105); # i
  $rc .= chr(48); # 0
  $rc .= chr(83); # S
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(106); # j
  $rc .= chr(64); # @
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '~^X' => '
#
# Stub version of: ~^X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(0); # ^X

  return $rc;
}
',
          '\\Ed$<200/>\\Eb' => '
#
# Stub version of: \\Ed$<200/>\\Eb
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\377\\231' => '
#
# Stub version of: \\377\\231
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(153); # \\231

  return $rc;
}
',
          '\\E[1m$<2>' => '
#
# Stub version of: \\E[1m$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '^Az\\r' => '
#
# Stub version of: ^Az\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(122); # z
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E004' => '
#
# Stub version of: \\E004
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\E[%p1%dd' => '
#
# Stub version of: \\E[%p1%dd
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\E[=19h\\E.3\\E9\\E0O\\0\\0\\0\\0\\0\\E0o\\0\\0\\0\\0\\0\\E0J\\177\\0\\0\\0\\0' => '
#
# Stub version of: \\E[=19h\\E.3\\E9\\E0O\\0\\0\\0\\0\\0\\E0o\\0\\0\\0\\0\\0\\E0J\\177\\0\\0\\0\\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(79); # O
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(111); # o
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(74); # J
  $rc .= chr(127); # \\177
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0

  return $rc;
}
',
          '\\EO1;6P' => '
#
# Stub version of: \\EO1;6P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\ENM' => '
#
# Stub version of: \\ENM
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\E;`ZQ\\E\\:iC\\E\\:iE\\021' => '
#
# Stub version of: \\E;`ZQ\\E\\:iC\\E\\:iE\\021
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(59); # ;
  $rc .= chr(96); # `
  $rc .= chr(90); # Z
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\:
  $rc .= chr(105); # i
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\:
  $rc .= chr(105); # i
  $rc .= chr(69); # E
  $rc .= chr(17); # \\021

  return $rc;
}
',
          '\\E[?1;2c' => '
#
# Stub version of: \\E[?1;2c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E[r\\E[m\\E[2J\\E[H\\E[?7h\\E[?1;3;4;6l\\E[4l\\E>\\E[?1000l\\E[?25h' => '
#
# Stub version of: \\E[r\\E[m\\E[2J\\E[H\\E[?7h\\E[?1;3;4;6l\\E[4l\\E>\\E[?1000l\\E[?25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[250z' => '
#
# Stub version of: \\E[250z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dH$<5/>' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dH$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E0$<5>' => '
#
# Stub version of: \\E0$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E008' => '
#
# Stub version of: \\E008
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E!c\\r' => '
#
# Stub version of: \\E!c\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(99); # c
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\ES\\E#\\E*\\Eh\\Em\\E?\\E1\\E9\\E@\\EX\\EU' => '
#
# Stub version of: \\ES\\E#\\E*\\Eh\\Em\\E?\\E1\\E9\\E@\\EX\\EU
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U

  return $rc;
}
',
          '\\EM$<2*/>' => '
#
# Stub version of: \\EM$<2*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Esel' => '
#
# Stub version of: \\Esel
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(101); # e
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EF17' => '
#
# Stub version of: \\EF17
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\E+^^' => '
#
# Stub version of: \\E+^^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(0); # ^^

  return $rc;
}
',
          '\\E[10m\\E[0%?%p1%p3%|%t;7%;%?%p2%t;4%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p9%t;12%e;10%;%?%p7%t;9%;m' => '
#
# Stub version of: \\E[10m\\E[0%?%p1%p3%|%t;7%;%?%p2%t;4%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p9%t;12%e;10%;%?%p7%t;9%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(50); # 2
  }
  else { # %e
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(48); # 0
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(57); # 9
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[0%?%p3%t;7%;%?%p4%t;5%;%?%p7%t;8%;m' => '
#
# Stub version of: \\E[0%?%p3%t;7%;%?%p4%t;5%;%?%p7%t;8%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E*$<300>' => '
#
# Stub version of: \\E*$<300>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\n$<9>' => '
#
# Stub version of: \\n$<9>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(57); # 9
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EDB' => '
#
# Stub version of: \\EDB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[^_' => '
#
# Stub version of: \\E[^_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(0); # ^_

  return $rc;
}
',
          '\\E!^E' => '
#
# Stub version of: \\E!^E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(0); # ^E

  return $rc;
}
',
          '\\EY%p1%\' \'%+%c%p2%\' \'%+%c' => '
#
# Stub version of: \\EY%p1%\' \'%+%c%p2%\' \'%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  push(@iparam, $param[0]); # %p1
  push(@iparam, chr(32)); # %\' \'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, chr(32)); # %\' \'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[104z' => '
#
# Stub version of: \\E[104z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\ERF' => '
#
# Stub version of: \\ERF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E[?=h\\Ec\\E`\\E[?>h\\EPY99\\:98\\E\\\\' => '
#
# Stub version of: \\E[?=h\\Ec\\E`\\E[?>h\\EPY99\\:98\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(61); # =
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(62); # >
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(89); # Y
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\:
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\EW$<5>' => '
#
# Stub version of: \\EW$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          'f10' => '
#
# Stub version of: f10
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(102); # f
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[19;1|\\E[21;4|\\Eent' => '
#
# Stub version of: \\E[19;1|\\E[21;4|\\Eent
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(110); # n
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\E[13;6~' => '
#
# Stub version of: \\E[13;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^^3' => '
#
# Stub version of: ^^3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[64;1H' => '
#
# Stub version of: \\E[64;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E\'0' => '
#
# Stub version of: \\E\'0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\Eq-%p1%d;' => '
#
# Stub version of: \\Eq-%p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(45); # -
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E`4\\E`1' => '
#
# Stub version of: \\E`4\\E`1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\ER$<1*>$<100>' => '
#
# Stub version of: \\ER$<1*>$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(62); # >
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\223' => '
#
# Stub version of: \\377\\223
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(147); # \\223

  return $rc;
}
',
          '\\E[42~' => '
#
# Stub version of: \\E[42~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[05' => '
#
# Stub version of: \\E[05
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E[0ZZ' => '
#
# Stub version of: \\E[0ZZ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(90); # Z
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\Em~\\s' => '
#
# Stub version of: \\Em~\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(126); # ~
  $rc .= chr(32); # \\s

  return $rc;
}
',
          'red' => '
#
# Stub version of: red
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(114); # r
  $rc .= chr(101); # e
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\E[33;1p\\E[255;1H\\E[K' => '
#
# Stub version of: \\E[33;1p\\E[255;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E&w6f80X' => '
#
# Stub version of: \\E&w6f80X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(54); # 6
  $rc .= chr(102); # f
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(88); # X

  return $rc;
}
',
          '\\EFS' => '
#
# Stub version of: \\EFS
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\ER$<5*/>' => '
#
# Stub version of: \\ER$<5*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\023$<160>' => '
#
# Stub version of: \\023$<160>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(19); # \\023
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?6l\\E[H\\E[J' => '
#
# Stub version of: \\E[?6l\\E[H\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E%!1\\E[m' => '
#
# Stub version of: \\E%!1\\E[m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\251' => '
#
# Stub version of: \\251
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(169); # \\251

  return $rc;
}
',
          '\\E&v%?%p2%{1000}%=%t1%e.%p2%d%;a%?%p3%{1000}%=%t1%e.%p3%d%;b%?%p4%{1000}%=%t1%e.%p4%d%;c%?%p5%{1000}%=%t1%e.%p5%d%;x%?%p6%{1000}%=%t1%e.%p6%d%;y%?%p7%{1000}%=%t1%e.%p7%d%;z%p1%dI' => '
#
# Stub version of: \\E&v%?%p2%{1000}%=%t1%e.%p2%d%;a%?%p3%{1000}%=%t1%e.%p3%d%;b%?%p4%{1000}%=%t1%e.%p4%d%;c%?%p5%{1000}%=%t1%e.%p5%d%;x%?%p6%{1000}%=%t1%e.%p6%d%;y%?%p7%{1000}%=%t1%e.%p7%d%;z%p1%dI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, 1000); # %{1000}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  else { # %e
    $rc .= chr(46); # .
    push(@iparam, $param[1]); # %p2
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(97); # a
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, 1000); # %{1000}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  else { # %e
    $rc .= chr(46); # .
    push(@iparam, $param[2]); # %p3
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(98); # b
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           push(@iparam, 1000); # %{1000}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  else { # %e
    $rc .= chr(46); # .
    push(@iparam, $param[3]); # %p4
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(99); # c
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           push(@iparam, 1000); # %{1000}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  else { # %e
    $rc .= chr(46); # .
    push(@iparam, $param[4]); # %p5
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(120); # x
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           push(@iparam, 1000); # %{1000}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  else { # %e
    $rc .= chr(46); # .
    push(@iparam, $param[5]); # %p6
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(121); # y
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           push(@iparam, 1000); # %{1000}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  else { # %e
    $rc .= chr(46); # .
    push(@iparam, $param[6]); # %p7
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(122); # z
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(73); # I

  return $rc;
}
',
          '~\\023$<6>' => '
#
# Stub version of: ~\\023$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(19); # \\023
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E^A\\r' => '
#
# Stub version of: \\E^A\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^A
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[m\\E[J' => '
#
# Stub version of: \\E[m\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E"\\EY' => '
#
# Stub version of: \\E"\\EY
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y

  return $rc;
}
',
          '\\E[006z' => '
#
# Stub version of: \\E[006z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\037era\\r\\n\\n' => '
#
# Stub version of: \\037era\\r\\n\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(101); # e
  $rc .= chr(114); # r
  $rc .= chr(97); # a
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\E[H\\E[J$<156>\\E[48;0;0;48p' => '
#
# Stub version of: \\E[H\\E[J$<156>\\E[48;0;0;48p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\ES7\\s' => '
#
# Stub version of: \\ES7\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(55); # 7
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E4>b' => '
#
# Stub version of: \\E4>b
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(62); # >
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\Ee6\\E~"$<100>\\E+\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`\\:\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<100>' => '
#
# Stub version of: \\Ee6\\E~"$<100>\\E+\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`\\:\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(34); # "
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(55); # 7
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E%!1\\E[m$<2>\\E%!0' => '
#
# Stub version of: \\E%!1\\E[m$<2>\\E%!0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E&v0m1a0b0c2i1a1b0c1i0a1b1c0i0S\\E&j@\\r\\E3\\r' => '
#
# Stub version of: \\E&v0m1a0b0c2i1a1b0c1i0a1b1c0i0S\\E&j@\\r\\E3\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(49); # 1
  $rc .= chr(97); # a
  $rc .= chr(48); # 0
  $rc .= chr(98); # b
  $rc .= chr(48); # 0
  $rc .= chr(99); # c
  $rc .= chr(50); # 2
  $rc .= chr(105); # i
  $rc .= chr(49); # 1
  $rc .= chr(97); # a
  $rc .= chr(49); # 1
  $rc .= chr(98); # b
  $rc .= chr(48); # 0
  $rc .= chr(99); # c
  $rc .= chr(49); # 1
  $rc .= chr(105); # i
  $rc .= chr(48); # 0
  $rc .= chr(97); # a
  $rc .= chr(49); # 1
  $rc .= chr(98); # b
  $rc .= chr(49); # 1
  $rc .= chr(99); # c
  $rc .= chr(48); # 0
  $rc .= chr(105); # i
  $rc .= chr(48); # 0
  $rc .= chr(83); # S
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(106); # j
  $rc .= chr(64); # @
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\020$<5.5*>' => '
#
# Stub version of: \\020$<5.5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\021$<5.5*>' => '
#
# Stub version of: \\021$<5.5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(17); # \\021
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&dD' => '
#
# Stub version of: \\E&dD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[%p1%dA' => '
#
# Stub version of: \\E[%p1%dA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\377\\345' => '
#
# Stub version of: \\377\\345
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(229); # \\345

  return $rc;
}
',
          '\\E[>11h\\EPO**x0/65;1/67\\E\\\\$<250>' => '
#
# Stub version of: \\E[>11h\\EPO**x0/65;1/67\\E\\\\$<250>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(79); # O
  $rc .= chr(42); # *
  $rc .= chr(42); # *
  $rc .= chr(120); # x
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(47); # /
  $rc .= chr(54); # 6
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EFk' => '
#
# Stub version of: \\EFk
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\233[%i%d;%dR' => '
#
# Stub version of: \\233[%i%d;%dR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E7\\E[25;%p1%{8}%+%dH' => '
#
# Stub version of: \\E7\\E[25;%p1%{8}%+%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  push(@iparam, 8); # %{8}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\233204z' => '
#
# Stub version of: \\233204z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EFd' => '
#
# Stub version of: \\EFd
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\E[9/y\\E[12/y\\E[=6l' => '
#
# Stub version of: \\E[9/y\\E[12/y\\E[=6l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(47); # /
  $rc .= chr(121); # y
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(121); # y
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(54); # 6
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[?6h\\E8' => '
#
# Stub version of: \\E[?6h\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\Ea' => '
#
# Stub version of: \\Ea
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\0Q' => '
#
# Stub version of: \\0Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E(B\\E[2l\\E>\\E[20l\\E[?3l\\E[?5h\\E[?7h\\E[H\\E[J' => '
#
# Stub version of: \\E(B\\E[2l\\E>\\E[20l\\E[?3l\\E[?5h\\E[?7h\\E[H\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\EM$<5/>' => '
#
# Stub version of: \\EM$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E<\\E=\\E[?1l\\E[?4l\\E[?5l\\E[?7h\\E[?8h$<300>' => '
#
# Stub version of: \\E<\\E=\\E[?1l\\E[?4l\\E[?5l\\E[?7h\\E[?8h$<300>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '5' => '
#
# Stub version of: 5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E`\\:\\Ee(\\EO\\Ee6\\Ec41\\E~4\\Ec21\\Ed/\\Ezz&\\E[A\\177\\Ezz\'\\E[B\\177\\Ezz(\\E[D\\177\\Ezz)\\E[C\\177\\Ezz<\\E[Q\\177\\Ezz`\\E[F\\177\\EA1*\\EZH12' => '
#
# Stub version of: \\E`\\:\\Ee(\\EO\\Ee6\\Ec41\\E~4\\Ec21\\Ed/\\Ezz&\\E[A\\177\\Ezz\'\\E[B\\177\\Ezz(\\E[D\\177\\Ezz)\\E[C\\177\\Ezz<\\E[Q\\177\\Ezz`\\E[F\\177\\EA1*\\EZH12
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(38); # &
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(66); # B
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(68); # D
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(41); # )
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(67); # C
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(81); # Q
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(96); # `
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(70); # F
  $rc .= chr(127); # \\177
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(90); # Z
  $rc .= chr(72); # H
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E[195z' => '
#
# Stub version of: \\E[195z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(53); # 5
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EE$<1*>$<100>' => '
#
# Stub version of: \\EE$<1*>$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(62); # >
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ed$\\EcD\\E\'\\Er\\EH\\003\\Ed/\\EO\\Ee1\\Ed*\\E`@\\E`9\\E`1\\016\\024\\El' => '
#
# Stub version of: \\Ed$\\EcD\\E\'\\Er\\EH\\003\\Ed/\\EO\\Ee1\\Ed*\\E`@\\E`9\\E`1\\016\\024\\El
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(36); # $
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(68); # D
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1
  $rc .= chr(14); # \\016
  $rc .= chr(20); # \\024
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l

  return $rc;
}
',
          '^Z3' => '
#
# Stub version of: ^Z3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Z
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[303z' => '
#
# Stub version of: \\E[303z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EK$<16>' => '
#
# Stub version of: \\EK$<16>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[!w' => '
#
# Stub version of: \\E[!w
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\E[J$<30/>' => '
#
# Stub version of: \\E[J$<30/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EyH' => '
#
# Stub version of: \\EyH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E_%p1%{63}%+%c%p2%s\\r' => '
#
# Stub version of: \\E_%p1%{63}%+%c%p2%s\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  push(@iparam, $param[0]); # %p1
  push(@iparam, 63); # %{63}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\0_' => '
#
# Stub version of: \\0_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(95); # _

  return $rc;
}
',
          '\\217B' => '
#
# Stub version of: \\217B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(66); # B

  return $rc;
}
',
          '``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~' => '
#
# Stub version of: ``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(121); # y
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(123); # {
  $rc .= chr(123); # {
  $rc .= chr(124); # |
  $rc .= chr(124); # |
  $rc .= chr(125); # }
  $rc .= chr(125); # }
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E}\\EC\\EX\\Ee\\En\\E%\\Er\\E(\\Ek\\Em\\Eq\\Ed\\ET\\EC\\E9\\EF' => '
#
# Stub version of: \\E}\\EC\\EX\\Ee\\En\\E%\\Er\\E(\\Ek\\Em\\Eq\\Ed\\ET\\EC\\E9\\EF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(125); # }
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(27); # \\E
  $rc .= chr(110); # n
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\El\\E"\\EF1\\E.3\\017\\EA\\E<' => '
#
# Stub version of: \\El\\E"\\EF1\\E.3\\017\\EA\\E<
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(51); # 3
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(60); # <

  return $rc;
}
',
          '\\Ei' => '
#
# Stub version of: \\Ei
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E[1K$<1>' => '
#
# Stub version of: \\E[1K$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E~B' => '
#
# Stub version of: \\E~B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(66); # B

  return $rc;
}
',
          '1$<10>' => '
#
# Stub version of: 1$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Eprior' => '
#
# Stub version of: \\Eprior
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(114); # r
  $rc .= chr(105); # i
  $rc .= chr(111); # o
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E&f2a%p1%dk0d%p2%l%dL%p2%s' => '
#
# Stub version of: \\E&f2a%p1%dk0d%p2%l%dL%p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(102); # f
  $rc .= chr(50); # 2
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(107); # k
  $rc .= chr(48); # 0
  $rc .= chr(100); # d
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\E"2\\EG0\\E]' => '
#
# Stub version of: \\E"2\\EG0\\E]
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]

  return $rc;
}
',
          '\\EC$<20>' => '
#
# Stub version of: \\EC$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E>\\E[?41;1r' => '
#
# Stub version of: \\E>\\E[?41;1r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[=3;<7m' => '
#
# Stub version of: \\E[=3;<7m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          'F2' => '
#
# Stub version of: F2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E=%p1%{32}%+%c%p2%{32}%+%c$<10>' => '
#
# Stub version of: \\E=%p1%{32}%+%c%p2%{32}%+%c$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[013q' => '
#
# Stub version of: \\E[013q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\0V' => '
#
# Stub version of: \\0V
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(86); # V

  return $rc;
}
',
          '\\EE$<0.7*/>' => '
#
# Stub version of: \\EE$<0.7*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(48); # 0
  $rc .= chr(46); # .
  $rc .= chr(55); # 7
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[6;4~' => '
#
# Stub version of: \\E[6;4~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E]12;%p1%s\\007' => '
#
# Stub version of: \\E]12;%p1%s\\007
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(7); # \\007

  return $rc;
}
',
          '\\Em^C' => '
#
# Stub version of: \\Em^C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(0); # ^C

  return $rc;
}
',
          '\\EFO' => '
#
# Stub version of: \\EFO
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\Ef\\r\\Eg' => '
#
# Stub version of: \\Ef\\r\\Eg
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\011$<8/>' => '
#
# Stub version of: \\011$<8/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(9); # \\011
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EG5' => '
#
# Stub version of: \\EG5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E[1p' => '
#
# Stub version of: \\E[1p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\Ew\\EA\\E\'\\E"\\E(' => '
#
# Stub version of: \\Ew\\EA\\E\'\\E"\\E(
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (

  return $rc;
}
',
          '\\233P' => '
#
# Stub version of: \\233P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[H\\E[J$<156>\\E[40;0;0;40p' => '
#
# Stub version of: \\E[H\\E[J$<156>\\E[40;0;0;40p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[K$<3>' => '
#
# Stub version of: \\E[K$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\035\\343\\035\\345' => '
#
# Stub version of: \\035\\343\\035\\345
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(227); # \\343
  $rc .= chr(29); # \\035
  $rc .= chr(229); # \\345

  return $rc;
}
',
          '\\E[%?%p2%t4;%;%?%p4%t5;%;%?%p6%t1;%;%?%p1%p2%|%p3%!%t7;%;%?%p7%t8;%;m\\016' => '
#
# Stub version of: \\E[%?%p2%t4;%;%?%p4%t5;%;%?%p6%t1;%;%?%p1%p2%|%p3%!%t7;%;%?%p7%t8;%;m\\016
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[1]); # %p2
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[2]); # %p3
           push(@iparam, ! pop(@iparam)); # %!
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(56); # 8
    $rc .= chr(59); # ;
  } # %;
  $rc .= chr(109); # m
  $rc .= chr(14); # \\016

  return $rc;
}
',
          '\\E[?3h' => '
#
# Stub version of: \\E[?3h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[40h\\E7\\E[25;%i%p1%dH' => '
#
# Stub version of: \\E[40h\\E7\\E[25;%i%p1%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\0H' => '
#
# Stub version of: \\0H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[0;10%?%p1%t;7%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;11%;m%?%p5%t\\E[=8F%;' => '
#
# Stub version of: \\E[0;10%?%p1%t;7%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;11%;m%?%p5%t\\E[=8F%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(61); # =
    $rc .= chr(56); # 8
    $rc .= chr(70); # F
  } # %;

  return $rc;
}
',
          '\\E[11;2~' => '
#
# Stub version of: \\E[11;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^]^P1' => '
#
# Stub version of: ^]^P1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^]
  $rc .= chr(0); # ^P
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[%?%p1%{25}%<%t%p1%e%p1%{24}%-%;%d;%p2%l%02d%?%p1%{25}%<%tq   SYS     F%p1%:-2d  %e;0;3q%;%p2%s' => '
#
# Stub version of: \\E[%?%p1%{25}%<%t%p1%e%p1%{24}%-%;%d;%p2%l%02d%?%p1%{25}%<%tq   SYS     F%p1%:-2d  %e;0;3q%;%p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 25); # %{25}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    push(@iparam, $param[0]); # %p1
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    push(@iparam, 24); # %{24}
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  } # %;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%02d\', pop(@iparam)); # %02d
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 25); # %{25}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    $rc .= chr(113); # q
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(83); # S
    $rc .= chr(89); # Y
    $rc .= chr(83); # S
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(32); #  
    $rc .= chr(70); # F
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%-2d\', pop(@iparam)); # %-2d
    $rc .= chr(32); #  
    $rc .= chr(32); #  
  }
  else { # %e
    $rc .= chr(59); # ;
    $rc .= chr(48); # 0
    $rc .= chr(59); # ;
    $rc .= chr(51); # 3
    $rc .= chr(113); # q
  } # %;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\E\\001\\E0' => '
#
# Stub version of: \\E\\001\\E0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[%p1%d q' => '
#
# Stub version of: \\E[%p1%d q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(32); #  
  $rc .= chr(113); # q

  return $rc;
}
',
          'F1' => '
#
# Stub version of: F1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[y' => '
#
# Stub version of: \\E[y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(121); # y

  return $rc;
}
',
          '\\EO1;3D' => '
#
# Stub version of: \\EO1;3D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E5S' => '
#
# Stub version of: \\E5S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(53); # 5
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E%!0\\ETD70\\E%!1' => '
#
# Stub version of: \\E%!0\\ETD70\\E%!1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(68); # D
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[210q' => '
#
# Stub version of: \\E[210q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[26;2~' => '
#
# Stub version of: \\E[26;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\002\\Es\\003' => '
#
# Stub version of: \\002\\Es\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(2); # \\002
  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '\\r$<2>' => '
#
# Stub version of: \\r$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^)' => '
#
# Stub version of: ^^)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(41); # )

  return $rc;
}
',
          '\\E[1w\\E[>37m\\E[>39m\\E[1v\\E[20l\\E[?3l\\E[?6l\\E[>5h\\E[>6h\\E[>7h\\E[>8l\\E[>9h\\E[>10l\\E[1;24r\\E[m\\E[q\\E(B\\017\\E)0\\E#5\\E>' => '
#
# Stub version of: \\E[1w\\E[>37m\\E[>39m\\E[1v\\E[20l\\E[?3l\\E[?6l\\E[>5h\\E[>6h\\E[>7h\\E[>8l\\E[>9h\\E[>10l\\E[1;24r\\E[m\\E[q\\E(B\\017\\E)0\\E#5\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(51); # 3
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(51); # 3
  $rc .= chr(57); # 9
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(54); # 6
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(56); # 8
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(57); # 9
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(53); # 5
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[]' => '
#
# Stub version of: \\E[]
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(93); # ]

  return $rc;
}
',
          '\\E[2D' => '
#
# Stub version of: \\E[2D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E^\\' => '
#
# Stub version of: \\E^\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(94); # ^
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\002\\E~\\003' => '
#
# Stub version of: \\002\\E~\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(2); # \\002
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '\\EOD' => '
#
# Stub version of: \\EOD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[%p1%dP$<5>' => '
#
# Stub version of: \\E[%p1%dP$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '^_!' => '
#
# Stub version of: ^_!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^_
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\EOV' => '
#
# Stub version of: \\EOV
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(86); # V

  return $rc;
}
',
          '\\E[?1034h' => '
#
# Stub version of: \\E[?1034h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[39;40m' => '
#
# Stub version of: \\E[39;40m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\377\\243' => '
#
# Stub version of: \\377\\243
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(163); # \\243

  return $rc;
}
',
          '\\E[2;1;1;1v\\E(B\\E)4\\017' => '
#
# Stub version of: \\E[2;1;1;1v\\E(B\\E)4\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(52); # 4
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\377\\316' => '
#
# Stub version of: \\377\\316
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(206); # \\316

  return $rc;
}
',
          '^^^H' => '
#
# Stub version of: ^^^H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(0); # ^H

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\233022z' => '
#
# Stub version of: \\233022z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E$S' => '
#
# Stub version of: \\E$S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\EEL' => '
#
# Stub version of: \\EEL
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\E%p1%da$<3*>' => '
#
# Stub version of: \\E%p1%da$<3*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(97); # a
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0;1;7m' => '
#
# Stub version of: \\E[0;1;7m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[011q' => '
#
# Stub version of: \\E[011q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\EF7' => '
#
# Stub version of: \\EF7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\E[013z' => '
#
# Stub version of: \\E[013z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E4=b' => '
#
# Stub version of: \\E4=b
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(61); # =
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\EH$<20>\\EJ$<80>' => '
#
# Stub version of: \\EH$<20>\\EJ$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[OQ' => '
#
# Stub version of: \\E[OQ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(79); # O
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E[306z' => '
#
# Stub version of: \\E[306z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\020\\025\\020\\023\\020\\023' => '
#
# Stub version of: \\020\\025\\020\\023\\020\\023
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  $rc .= chr(21); # \\025
  $rc .= chr(16); # \\020
  $rc .= chr(19); # \\023
  $rc .= chr(16); # \\020
  $rc .= chr(19); # \\023

  return $rc;
}
',
          '\\037%p2%{32}%+%c%p1%{32}%+%c' => '
#
# Stub version of: \\037%p2%{32}%+%c%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[%p1%dL$<5>' => '
#
# Stub version of: \\E[%p1%dL$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1;6S' => '
#
# Stub version of: \\E[1;6S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E.b\\E[10;20v\\E[14;1v\\E[3;0v\\E[7;0v\\E[=11.h\\E[=12.h\\E[=13.h\\E[=14.h\\E[=15l\\E[=20h\\E[=60l\\E[=61h\\E[=9l\\E[=10l\\E[=21l\\E[=23l\\E[=3l\\E_40\\E_50\\En\\Ew\\Ee \\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\Ex3\\0\\0\\Ex4\\0\\0\\E1' => '
#
# Stub version of: \\E.b\\E[10;20v\\E[14;1v\\E[3;0v\\E[7;0v\\E[=11.h\\E[=12.h\\E[=13.h\\E[=14.h\\E[=15l\\E[=20h\\E[=60l\\E[=61h\\E[=9l\\E[=10l\\E[=21l\\E[=23l\\E[=3l\\E_40\\E_50\\En\\Ew\\Ee \\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\Ex3\\0\\0\\Ex4\\0\\0\\E1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(46); # .
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(46); # .
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(46); # .
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(46); # .
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(54); # 6
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(57); # 9
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(110); # n
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(52); # 4
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E&a0c0Y\\EJ$<40>' => '
#
# Stub version of: \\E&a0c0Y\\EJ$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  $rc .= chr(48); # 0
  $rc .= chr(99); # c
  $rc .= chr(48); # 0
  $rc .= chr(89); # Y
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E#W' => '
#
# Stub version of: \\E#W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\E[17p' => '
#
# Stub version of: \\E[17p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\EE%p1%d;%p2%d;' => '
#
# Stub version of: \\EE%p1%d;%p2%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '^NQ' => '
#
# Stub version of: ^NQ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^N
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E[20;3~' => '
#
# Stub version of: \\E[20;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\r\\n\\E[A\\E7\\E[255;1;0;44;80;80p\\E8\\E[J' => '
#
# Stub version of: \\r\\n\\E[A\\E7\\E[255;1;0;44;80;80p\\E8\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E=\\001\\001' => '
#
# Stub version of: \\E=\\001\\001
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(1); # \\001
  $rc .= chr(1); # \\001

  return $rc;
}
',
          '<1.5/>' => '
#
# Stub version of: <1.5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E?\\E\\005$<2*>' => '
#
# Stub version of: \\E?\\E\\005$<2*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(27); # \\E
  $rc .= chr(5); # \\005
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[307z' => '
#
# Stub version of: \\E[307z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\026J$<5.5*>' => '
#
# Stub version of: \\026J$<5.5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(22); # \\026
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\021%p2%c%p1%c' => '
#
# Stub version of: \\E\\021%p2%c%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(17); # \\021
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E.1' => '
#
# Stub version of: \\E.1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\EG0\\E%' => '
#
# Stub version of: \\EG0\\E%
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %

  return $rc;
}
',
          '\\E[M$<40>' => '
#
# Stub version of: \\E[M$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ek%p1%d;%p2%d;' => '
#
# Stub version of: \\Ek%p1%d;%p2%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '^B8^J' => '
#
# Stub version of: ^B8^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(56); # 8
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '\\E[?3l$<100>' => '
#
# Stub version of: \\E[?3l$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\233?1l\\E>' => '
#
# Stub version of: \\233?1l\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[B' => '
#
# Stub version of: \\E[B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E\\\\' => '
#
# Stub version of: \\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E[1;24r\\E8' => '
#
# Stub version of: \\E[1;24r\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[023q' => '
#
# Stub version of: \\E[023q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E~Q' => '
#
# Stub version of: \\E~Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E]l\\E\\\\' => '
#
# Stub version of: \\E]l\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E[2u\\027' => '
#
# Stub version of: \\E[2u\\027
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(117); # u
  $rc .= chr(23); # \\027

  return $rc;
}
',
          '\\035dli;' => '
#
# Stub version of: \\035dli;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(100); # d
  $rc .= chr(108); # l
  $rc .= chr(105); # i
  $rc .= chr(59); # ;

  return $rc;
}
',
          '^B@\\r' => '
#
# Stub version of: ^B@\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(64); # @
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '+>\\,<-\\^.v0#`+a\\:f\\\\h#i#j+k+l+m+n+o~p-q-r-s_t+u+v+w+x|y#z#{*|!}#~o' => '
#
# Stub version of: +>\\,<-\\^.v0#`+a\\:f\\\\h#i#j+k+l+m+n+o~p-q-r-s_t+u+v+w+x|y#z#{*|!}#~o
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(62); # >
  $rc .= chr(128); # \\,
  $rc .= chr(60); # <
  $rc .= chr(45); # -
  $rc .= chr(128); # \\^
  $rc .= chr(46); # .
  $rc .= chr(118); # v
  $rc .= chr(48); # 0
  $rc .= chr(35); # #
  $rc .= chr(96); # `
  $rc .= chr(43); # +
  $rc .= chr(97); # a
  $rc .= chr(128); # \\:
  $rc .= chr(102); # f
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(104); # h
  $rc .= chr(35); # #
  $rc .= chr(105); # i
  $rc .= chr(35); # #
  $rc .= chr(106); # j
  $rc .= chr(43); # +
  $rc .= chr(107); # k
  $rc .= chr(43); # +
  $rc .= chr(108); # l
  $rc .= chr(43); # +
  $rc .= chr(109); # m
  $rc .= chr(43); # +
  $rc .= chr(110); # n
  $rc .= chr(43); # +
  $rc .= chr(111); # o
  $rc .= chr(126); # ~
  $rc .= chr(112); # p
  $rc .= chr(45); # -
  $rc .= chr(113); # q
  $rc .= chr(45); # -
  $rc .= chr(114); # r
  $rc .= chr(45); # -
  $rc .= chr(115); # s
  $rc .= chr(95); # _
  $rc .= chr(116); # t
  $rc .= chr(43); # +
  $rc .= chr(117); # u
  $rc .= chr(43); # +
  $rc .= chr(118); # v
  $rc .= chr(43); # +
  $rc .= chr(119); # w
  $rc .= chr(43); # +
  $rc .= chr(120); # x
  $rc .= chr(124); # |
  $rc .= chr(121); # y
  $rc .= chr(35); # #
  $rc .= chr(122); # z
  $rc .= chr(35); # #
  $rc .= chr(123); # {
  $rc .= chr(42); # *
  $rc .= chr(124); # |
  $rc .= chr(33); # !
  $rc .= chr(125); # }
  $rc .= chr(35); # #
  $rc .= chr(126); # ~
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\E[%?%p1%{8}%<%t%p1%{40}%+%e%p1%{92}%+%;%dm' => '
#
# Stub version of: \\E[%?%p1%{8}%<%t%p1%{40}%+%e%p1%{92}%+%;%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 8); # %{8}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    push(@iparam, $param[0]); # %p1
    push(@iparam, 40); # %{40}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    push(@iparam, 92); # %{92}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Ew' => '
#
# Stub version of: \\Ew
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\E\\n$<5/>' => '
#
# Stub version of: \\E\\n$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[=0C' => '
#
# Stub version of: \\E[=0C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(48); # 0
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[0J' => '
#
# Stub version of: \\E[0J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\Ef9' => '
#
# Stub version of: \\Ef9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(57); # 9

  return $rc;
}
',
          'jak`l_mbquvewcxs' => '
#
# Stub version of: jak`l_mbquvewcxs
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(106); # j
  $rc .= chr(97); # a
  $rc .= chr(107); # k
  $rc .= chr(96); # `
  $rc .= chr(108); # l
  $rc .= chr(95); # _
  $rc .= chr(109); # m
  $rc .= chr(98); # b
  $rc .= chr(113); # q
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(101); # e
  $rc .= chr(119); # w
  $rc .= chr(99); # c
  $rc .= chr(120); # x
  $rc .= chr(115); # s

  return $rc;
}
',
          '^^h' => '
#
# Stub version of: ^^h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\377\\302' => '
#
# Stub version of: \\377\\302
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(194); # \\302

  return $rc;
}
',
          '\\E[K$<5>' => '
#
# Stub version of: \\E[K$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\372' => '
#
# Stub version of: \\377\\372
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(250); # \\372

  return $rc;
}
',
          '^\\053\\r' => '
#
# Stub version of: ^\\053\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(43); # \\053
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E!9(N\\E>B' => '
#
# Stub version of: \\E!9(N\\E>B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(57); # 9
  $rc .= chr(40); # (
  $rc .= chr(78); # N
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E_D\\E\\\\' => '
#
# Stub version of: \\E_D\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(68); # D
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E=%p1%{32}%+%c%p2%{32}%+%c$<20>' => '
#
# Stub version of: \\E=%p1%{32}%+%c%p2%{32}%+%c$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[35~' => '
#
# Stub version of: \\E[35~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;m' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\377\\205' => '
#
# Stub version of: \\377\\205
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(133); # \\205

  return $rc;
}
',
          '^Ad\\r' => '
#
# Stub version of: ^Ad\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(100); # d
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[?5h\\E[?5l$<200/>' => '
#
# Stub version of: \\E[?5h\\E[?5l$<200/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ENs' => '
#
# Stub version of: \\ENs
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E)' => '
#
# Stub version of: \\E)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )

  return $rc;
}
',
          '\\E[0K$<20/>' => '
#
# Stub version of: \\E[0K$<20/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '%?%p9%t\\E(0%e\\E(B%;\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m' => '
#
# Stub version of: %?%p9%t\\E(0%e\\E(B%;\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E]l' => '
#
# Stub version of: \\E]l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[N' => '
#
# Stub version of: \\E[N
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(78); # N

  return $rc;
}
',
          '\\EKA1\\ELLB2\\ELV0\\ELV1' => '
#
# Stub version of: \\EKA1\\ELLB2\\ELV0\\ELV1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(65); # A
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(86); # V
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(86); # V
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\EH\\EA' => '
#
# Stub version of: \\EH\\EA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[025q' => '
#
# Stub version of: \\E[025q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E!\\0$<20>' => '
#
# Stub version of: \\E!\\0$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(128); # \\0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^Ot' => '
#
# Stub version of: ^Ot
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^O
  $rc .= chr(116); # t

  return $rc;
}
',
          '^\\H`' => '
#
# Stub version of: ^\\H`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(92); # \\
  $rc .= chr(72); # H
  $rc .= chr(96); # `

  return $rc;
}
',
          '^V$' => '
#
# Stub version of: ^V$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(36); # $

  return $rc;
}
',
          'Num 5' => '
#
# Stub version of: Num 5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(78); # N
  $rc .= chr(117); # u
  $rc .= chr(109); # m
  $rc .= chr(32); #  
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E[?;m' => '
#
# Stub version of: \\E[?;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(59); # ;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E&s1A\\E<\\E&k0\\\\' => '
#
# Stub version of: \\E&s1A\\E<\\E&k0\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(115); # s
  $rc .= chr(49); # 1
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(107); # k
  $rc .= chr(48); # 0
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E[029q' => '
#
# Stub version of: \\E[029q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E>\\E[?5l\\E[?7h' => '
#
# Stub version of: \\E>\\E[?5l\\E[?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\377\\364' => '
#
# Stub version of: \\377\\364
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(244); # \\364

  return $rc;
}
',
          '\\E#?' => '
#
# Stub version of: \\E#?
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(63); # ?

  return $rc;
}
',
          '\\s\\EdP' => '
#
# Stub version of: \\s\\EdP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(32); # \\s
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[?;%p1%dm' => '
#
# Stub version of: \\E[?;%p1%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E#8' => '
#
# Stub version of: \\E#8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\233%p1%d@' => '
#
# Stub version of: \\233%p1%d@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\EO2B' => '
#
# Stub version of: \\EO2B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(50); # 2
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[>59h$<100>\\E[>59l' => '
#
# Stub version of: \\E[>59h$<100>\\E[>59l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(57); # 9
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(57); # 9
  $rc .= chr(108); # l

  return $rc;
}
',
          '^X^]' => '
#
# Stub version of: ^X^]
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^X
  $rc .= chr(0); # ^]

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[k' => '
#
# Stub version of: \\E[k
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\377\\266' => '
#
# Stub version of: \\377\\266
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(182); # \\266

  return $rc;
}
',
          '\\E[1;1H\\E[0J\\E[?6h\\E[?1l' => '
#
# Stub version of: \\E[1;1H\\E[0J\\E[?6h\\E[?1l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[%p1%d;%p2%l%02dq   F%p1%d           %p2%s\\E~' => '
#
# Stub version of: \\E[%p1%d;%p2%l%02dq   F%p1%d           %p2%s\\E~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%02d\', pop(@iparam)); # %02d
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\377\\355' => '
#
# Stub version of: \\377\\355
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(237); # \\355

  return $rc;
}
',
          '!com 29\\035del 0\\035rss t\\035buf\\035buf n\\035cle\\035dis\\035dup\\035ech r\\035eol\\035era g\\035for n\\035pad 203\\035pad 209\\035sno n\\035sto 9 17 25 33 41 49 57 65 73\\035wor 0;' => '
#
# Stub version of: !com 29\\035del 0\\035rss t\\035buf\\035buf n\\035cle\\035dis\\035dup\\035ech r\\035eol\\035era g\\035for n\\035pad 203\\035pad 209\\035sno n\\035sto 9 17 25 33 41 49 57 65 73\\035wor 0;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(33); # !
  $rc .= chr(99); # c
  $rc .= chr(111); # o
  $rc .= chr(109); # m
  $rc .= chr(32); #  
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(29); # \\035
  $rc .= chr(100); # d
  $rc .= chr(101); # e
  $rc .= chr(108); # l
  $rc .= chr(32); #  
  $rc .= chr(48); # 0
  $rc .= chr(29); # \\035
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(32); #  
  $rc .= chr(116); # t
  $rc .= chr(29); # \\035
  $rc .= chr(98); # b
  $rc .= chr(117); # u
  $rc .= chr(102); # f
  $rc .= chr(29); # \\035
  $rc .= chr(98); # b
  $rc .= chr(117); # u
  $rc .= chr(102); # f
  $rc .= chr(32); #  
  $rc .= chr(110); # n
  $rc .= chr(29); # \\035
  $rc .= chr(99); # c
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(29); # \\035
  $rc .= chr(100); # d
  $rc .= chr(105); # i
  $rc .= chr(115); # s
  $rc .= chr(29); # \\035
  $rc .= chr(100); # d
  $rc .= chr(117); # u
  $rc .= chr(112); # p
  $rc .= chr(29); # \\035
  $rc .= chr(101); # e
  $rc .= chr(99); # c
  $rc .= chr(104); # h
  $rc .= chr(32); #  
  $rc .= chr(114); # r
  $rc .= chr(29); # \\035
  $rc .= chr(101); # e
  $rc .= chr(111); # o
  $rc .= chr(108); # l
  $rc .= chr(29); # \\035
  $rc .= chr(101); # e
  $rc .= chr(114); # r
  $rc .= chr(97); # a
  $rc .= chr(32); #  
  $rc .= chr(103); # g
  $rc .= chr(29); # \\035
  $rc .= chr(102); # f
  $rc .= chr(111); # o
  $rc .= chr(114); # r
  $rc .= chr(32); #  
  $rc .= chr(110); # n
  $rc .= chr(29); # \\035
  $rc .= chr(112); # p
  $rc .= chr(97); # a
  $rc .= chr(100); # d
  $rc .= chr(32); #  
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(29); # \\035
  $rc .= chr(112); # p
  $rc .= chr(97); # a
  $rc .= chr(100); # d
  $rc .= chr(32); #  
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(29); # \\035
  $rc .= chr(115); # s
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(32); #  
  $rc .= chr(110); # n
  $rc .= chr(29); # \\035
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(111); # o
  $rc .= chr(32); #  
  $rc .= chr(57); # 9
  $rc .= chr(32); #  
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(32); #  
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(32); #  
  $rc .= chr(53); # 5
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(32); #  
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(29); # \\035
  $rc .= chr(119); # w
  $rc .= chr(111); # o
  $rc .= chr(114); # r
  $rc .= chr(32); #  
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[0m\\017$<20>' => '
#
# Stub version of: \\E[0m\\017$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(15); # \\017
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[194z' => '
#
# Stub version of: \\E[194z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[=1;<6m' => '
#
# Stub version of: \\E[=1;<6m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[300z' => '
#
# Stub version of: \\E[300z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[5r' => '
#
# Stub version of: \\E[5r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\EM%p1%{32}%+%c%p2%d)' => '
#
# Stub version of: \\EM%p1%{32}%+%c%p2%d)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(41); # )

  return $rc;
}
',
          '^H' => '
#
# Stub version of: ^H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^H

  return $rc;
}
',
          '\\E\\021%p2%{32}%+%c%p1%{32}%+%c' => '
#
# Stub version of: \\E\\021%p2%{32}%+%c%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(17); # \\021
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[3C' => '
#
# Stub version of: \\E[3C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E+$<260>' => '
#
# Stub version of: \\E+$<260>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E}\\E]\\E>\\E)' => '
#
# Stub version of: \\E}\\E]\\E>\\E)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(125); # }
  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )

  return $rc;
}
',
          '\\E[034q' => '
#
# Stub version of: \\E[034q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\EG0%?%p1%t\\EGt%;%?%p2%t\\EG8%;%?%p3%t\\EG4%;%?%p4%t\\EG2%;%?%p5%t\\EGp%;%?%p6%t\\EG\\,%;%?%p7%t\\EG1%;%?%p8%t\\E&%;%?%p9%t\\E$%e\\E%%%;' => '
#
# Stub version of: \\EG0%?%p1%t\\EGt%;%?%p2%t\\EG8%;%?%p3%t\\EG4%;%?%p4%t\\EG2%;%?%p5%t\\EGp%;%?%p6%t\\EG\\,%;%?%p7%t\\EG1%;%?%p8%t\\E&%;%?%p9%t\\E$%e\\E%%%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(71); # G
    $rc .= chr(116); # t
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(71); # G
    $rc .= chr(56); # 8
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(71); # G
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(71); # G
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(71); # G
    $rc .= chr(112); # p
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(71); # G
    $rc .= chr(128); # \\,
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(71); # G
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[7]); # %p8
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(36); # $
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= \'%\';
  } # %;

  return $rc;
}
',
          '\\E[18\\^' => '
#
# Stub version of: \\E[18\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\013$<40>' => '
#
# Stub version of: \\013$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?2h\\E[?3l\\E[?5h\\E[?7h\\E[?8h\\E>\\E[?1l\\E F\\E[?42l\\E[?4l' => '
#
# Stub version of: \\E[?2h\\E[?3l\\E[?5h\\E[?7h\\E[?8h\\E>\\E[?1l\\E F\\E[?42l\\E[?4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[30~' => '
#
# Stub version of: \\E[30~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EAUN' => '
#
# Stub version of: \\EAUN
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(85); # U
  $rc .= chr(78); # N

  return $rc;
}
',
          '\\233?5h$<50>\\233?5l' => '
#
# Stub version of: \\233?5h$<50>\\233?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\Ep-%p1%d;' => '
#
# Stub version of: \\Ep-%p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(45); # -
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?20l\\E[?7h\\E[?8h' => '
#
# Stub version of: \\E>\\E[?3l\\E[?4l\\E[?5l\\E[?20l\\E[?7h\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EZ$<10>' => '
#
# Stub version of: \\EZ$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(90); # Z
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\2335m' => '
#
# Stub version of: \\2335m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(53); # 5
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[@$<4>' => '
#
# Stub version of: \\E[@$<4>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(64); # @
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[K' => '
#
# Stub version of: \\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\2338m' => '
#
# Stub version of: \\2338m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(56); # 8
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Ee6\\E~4$<100>\\E+\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`\\:\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<100>' => '
#
# Stub version of: \\Ee6\\E~4$<100>\\E+\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`\\:\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(52); # 4
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(55); # 7
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EX' => '
#
# Stub version of: \\EX
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(88); # X

  return $rc;
}
',
          '^^^V' => '
#
# Stub version of: ^^^V
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(0); # ^V

  return $rc;
}
',
          '\\E_%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\E_%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\EO\\Eq\\EG\\EwK4' => '
#
# Stub version of: \\EO\\Eq\\EG\\EwK4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(75); # K
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\E[!p' => '
#
# Stub version of: \\E[!p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[?1h\\E' => '
#
# Stub version of: \\E[?1h\\E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E

  return $rc;
}
',
          '\\E[%p1%dD' => '
#
# Stub version of: \\E[%p1%dD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\ENc' => '
#
# Stub version of: \\ENc
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E>\\E[?3h\\E[?4l\\E[?5l\\E[?7h\\E[?8h' => '
#
# Stub version of: \\E>\\E[?3h\\E[?4l\\E[?5l\\E[?7h\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[=103l\\E[=205h' => '
#
# Stub version of: \\E[=103l\\E[=205h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[?2h\\E[?3h\\E[?5l\\E[?7h\\E[?8h\\E>\\E[?1l\\E G\\E[?42l\\E[?4l' => '
#
# Stub version of: \\E[?2h\\E[?3h\\E[?5l\\E[?7h\\E[?8h\\E>\\E[?1l\\E G\\E[?42l\\E[?4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[23\\^' => '
#
# Stub version of: \\E[23\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\E(B\\E)1' => '
#
# Stub version of: \\E(B\\E)1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E\\001\\E9' => '
#
# Stub version of: \\E\\001\\E9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\E[62"p\\E G\\233m\\233?7h\\E>\\E7\\233?1;3;4;6l\\2334l\\233r\\E8' => '
#
# Stub version of: \\E[62"p\\E G\\233m\\233?7h\\E>\\E7\\233?1;3;4;6l\\2334l\\233r\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(50); # 2
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(71); # G
  $rc .= chr(155); # \\233
  $rc .= chr(109); # m
  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(155); # \\233
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(155); # \\233
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E!' => '
#
# Stub version of: \\E!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\0C' => '
#
# Stub version of: \\0C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[13;4~' => '
#
# Stub version of: \\E[13;4~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EwG\\Ee)$<200>' => '
#
# Stub version of: \\EwG\\Ee)$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(41); # )
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[m\\E[1m' => '
#
# Stub version of: \\E[m\\E[1m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EO3R' => '
#
# Stub version of: \\EO3R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(51); # 3
  $rc .= chr(82); # R

  return $rc;
}
',
          'blue' => '
#
# Stub version of: blue
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(98); # b
  $rc .= chr(108); # l
  $rc .= chr(117); # u
  $rc .= chr(101); # e

  return $rc;
}
',
          '^V-' => '
#
# Stub version of: ^V-
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(45); # -

  return $rc;
}
',
          '\\Eg0' => '
#
# Stub version of: \\Eg0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[4i' => '
#
# Stub version of: \\E[4i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(105); # i

  return $rc;
}
',
          '^P^S' => '
#
# Stub version of: ^P^S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(0); # ^S

  return $rc;
}
',
          '\\E[2;1H\\E[J$<50>' => '
#
# Stub version of: \\E[2;1H\\E[J$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[8m$<2>' => '
#
# Stub version of: \\E[8m$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[J$<96>' => '
#
# Stub version of: \\E[J$<96>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(57); # 9
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^^^\\177' => '
#
# Stub version of: ^^^^\\177
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(0); # ^^
  $rc .= chr(127); # \\177

  return $rc;
}
',
          '\\E[215z' => '
#
# Stub version of: \\E[215z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(122); # z

  return $rc;
}
',
          'f6' => '
#
# Stub version of: f6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(102); # f
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E[2ZZ' => '
#
# Stub version of: \\E[2ZZ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(90); # Z
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\E]P%?%p1%{9}%>%t%p1%{10}%-%\'a\'%+%c%e%p1%d%;%p2%{255}%*%{1000}%/%Pr%gr%{16}%/%Px%?%gx%{9}%>%t%gx%{10}%-%\'a\'%+%c%e%gx%d%;%gr%{15}%&%Px%?%gx%{9}%>%t%gx%{10}%-%\'a\'%+%c%e%gx%d%;%p3%{255}%*%{1000}%/%Pr%gr%{16}%/%Px%?%gx%{9}%>%t%gx%{10}%-%\'a\'%+%c%e%gx%d%;%gr%{15}%&%Px%?%gx%{9}%>%t%gx%{10}%-%\'a\'%+%c%e%gx%d%;%p4%{255}%*%{1000}%/%Pr%gr%{16}%/%Px%?%gx%{9}%>%t%gx%{10}%-%\'a\'%+%c%e%gx%d%;%gr%{15}%&%Px%?%gx%{9}%>%t%gx%{10}%-%\'a\'%+%c%e%gx%d%;' => '
#
# Stub version of: \\E]P%?%p1%{9}%>%t%p1%{10}%-%\'a\'%+%c%e%p1%d%;%p2%{255}%*%{1000}%/%Pr%gr%{16}%/%Px%?%gx%{9}%>%t%gx%{10}%-%\'a\'%+%c%e%gx%d%;%gr%{15}%&%Px%?%gx%{9}%>%t%gx%{10}%-%\'a\'%+%c%e%gx%d%;%p3%{255}%*%{1000}%/%Pr%gr%{16}%/%Px%?%gx%{9}%>%t%gx%{10}%-%\'a\'%+%c%e%gx%d%;%gr%{15}%&%Px%?%gx%{9}%>%t%gx%{10}%-%\'a\'%+%c%e%gx%d%;%p4%{255}%*%{1000}%/%Pr%gr%{16}%/%Px%?%gx%{9}%>%t%gx%{10}%-%\'a\'%+%c%e%gx%d%;%gr%{15}%&%Px%?%gx%{9}%>%t%gx%{10}%-%\'a\'%+%c%e%gx%d%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(80); # P
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 9); # %{9}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, $param[0]); # %p1
    push(@iparam, 10); # %{10}
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
    push(@iparam, chr(97)); # %\'a\'
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  push(@iparam, $param[1]); # %p2
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $dynamicp->[17] = pop(@iparam); # %Pr
  push(@iparam, $dynamicp->[17]); # %gr
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $dynamicp->[23] = pop(@iparam); # %Px
  if (do { # %?
           push(@iparam, $dynamicp->[23]); # %gx
           push(@iparam, 9); # %{9}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, $dynamicp->[23]); # %gx
    push(@iparam, 10); # %{10}
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
    push(@iparam, chr(97)); # %\'a\'
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  }
  else { # %e
    push(@iparam, $dynamicp->[23]); # %gx
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  push(@iparam, $dynamicp->[17]); # %gr
  push(@iparam, 15); # %{15}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  $dynamicp->[23] = pop(@iparam); # %Px
  if (do { # %?
           push(@iparam, $dynamicp->[23]); # %gx
           push(@iparam, 9); # %{9}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, $dynamicp->[23]); # %gx
    push(@iparam, 10); # %{10}
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
    push(@iparam, chr(97)); # %\'a\'
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  }
  else { # %e
    push(@iparam, $dynamicp->[23]); # %gx
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  push(@iparam, $param[2]); # %p3
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $dynamicp->[17] = pop(@iparam); # %Pr
  push(@iparam, $dynamicp->[17]); # %gr
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $dynamicp->[23] = pop(@iparam); # %Px
  if (do { # %?
           push(@iparam, $dynamicp->[23]); # %gx
           push(@iparam, 9); # %{9}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, $dynamicp->[23]); # %gx
    push(@iparam, 10); # %{10}
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
    push(@iparam, chr(97)); # %\'a\'
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  }
  else { # %e
    push(@iparam, $dynamicp->[23]); # %gx
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  push(@iparam, $dynamicp->[17]); # %gr
  push(@iparam, 15); # %{15}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  $dynamicp->[23] = pop(@iparam); # %Px
  if (do { # %?
           push(@iparam, $dynamicp->[23]); # %gx
           push(@iparam, 9); # %{9}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, $dynamicp->[23]); # %gx
    push(@iparam, 10); # %{10}
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
    push(@iparam, chr(97)); # %\'a\'
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  }
  else { # %e
    push(@iparam, $dynamicp->[23]); # %gx
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  push(@iparam, $param[3]); # %p4
  push(@iparam, 255); # %{255}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 1000); # %{1000}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $dynamicp->[17] = pop(@iparam); # %Pr
  push(@iparam, $dynamicp->[17]); # %gr
  push(@iparam, 16); # %{16}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $dynamicp->[23] = pop(@iparam); # %Px
  if (do { # %?
           push(@iparam, $dynamicp->[23]); # %gx
           push(@iparam, 9); # %{9}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, $dynamicp->[23]); # %gx
    push(@iparam, 10); # %{10}
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
    push(@iparam, chr(97)); # %\'a\'
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  }
  else { # %e
    push(@iparam, $dynamicp->[23]); # %gx
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  push(@iparam, $dynamicp->[17]); # %gr
  push(@iparam, 15); # %{15}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  $dynamicp->[23] = pop(@iparam); # %Px
  if (do { # %?
           push(@iparam, $dynamicp->[23]); # %gx
           push(@iparam, 9); # %{9}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, $dynamicp->[23]); # %gx
    push(@iparam, 10); # %{10}
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
    push(@iparam, chr(97)); # %\'a\'
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  }
  else { # %e
    push(@iparam, $dynamicp->[23]); # %gx
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;

  return $rc;
}
',
          '\\EO1;2D' => '
#
# Stub version of: \\EO1;2D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\EO1;5S' => '
#
# Stub version of: \\EO1;5S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E&jB' => '
#
# Stub version of: \\E&jB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(106); # j
  $rc .= chr(66); # B

  return $rc;
}
',
          '^Y^L' => '
#
# Stub version of: ^Y^L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Y
  $rc .= chr(0); # ^L

  return $rc;
}
',
          '\\E4@' => '
#
# Stub version of: \\E4@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\EW$<4/>' => '
#
# Stub version of: \\EW$<4/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ERc' => '
#
# Stub version of: \\ERc
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(99); # c

  return $rc;
}
',
          '30*\\ER' => '
#
# Stub version of: 30*\\ER
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[101z' => '
#
# Stub version of: \\E[101z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '+\\257\\,\\256-\\^.v0\\333I\\374`\\177a\\260f\\370g\\361h\\261j\\331k\\277l\\332m\\300n\\305o\\377p-q\\304r-s_t+u+v+w+x\\263y\\363z\\362{\\343|\\366}\\234~\\371' => '
#
# Stub version of: +\\257\\,\\256-\\^.v0\\333I\\374`\\177a\\260f\\370g\\361h\\261j\\331k\\277l\\332m\\300n\\305o\\377p-q\\304r-s_t+u+v+w+x\\263y\\363z\\362{\\343|\\366}\\234~\\371
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(175); # \\257
  $rc .= chr(128); # \\,
  $rc .= chr(174); # \\256
  $rc .= chr(45); # -
  $rc .= chr(128); # \\^
  $rc .= chr(46); # .
  $rc .= chr(118); # v
  $rc .= chr(48); # 0
  $rc .= chr(219); # \\333
  $rc .= chr(73); # I
  $rc .= chr(252); # \\374
  $rc .= chr(96); # `
  $rc .= chr(127); # \\177
  $rc .= chr(97); # a
  $rc .= chr(176); # \\260
  $rc .= chr(102); # f
  $rc .= chr(248); # \\370
  $rc .= chr(103); # g
  $rc .= chr(241); # \\361
  $rc .= chr(104); # h
  $rc .= chr(177); # \\261
  $rc .= chr(106); # j
  $rc .= chr(217); # \\331
  $rc .= chr(107); # k
  $rc .= chr(191); # \\277
  $rc .= chr(108); # l
  $rc .= chr(218); # \\332
  $rc .= chr(109); # m
  $rc .= chr(192); # \\300
  $rc .= chr(110); # n
  $rc .= chr(197); # \\305
  $rc .= chr(111); # o
  $rc .= chr(255); # \\377
  $rc .= chr(112); # p
  $rc .= chr(45); # -
  $rc .= chr(113); # q
  $rc .= chr(196); # \\304
  $rc .= chr(114); # r
  $rc .= chr(45); # -
  $rc .= chr(115); # s
  $rc .= chr(95); # _
  $rc .= chr(116); # t
  $rc .= chr(43); # +
  $rc .= chr(117); # u
  $rc .= chr(43); # +
  $rc .= chr(118); # v
  $rc .= chr(43); # +
  $rc .= chr(119); # w
  $rc .= chr(43); # +
  $rc .= chr(120); # x
  $rc .= chr(179); # \\263
  $rc .= chr(121); # y
  $rc .= chr(243); # \\363
  $rc .= chr(122); # z
  $rc .= chr(242); # \\362
  $rc .= chr(123); # {
  $rc .= chr(227); # \\343
  $rc .= chr(124); # |
  $rc .= chr(246); # \\366
  $rc .= chr(125); # }
  $rc .= chr(156); # \\234
  $rc .= chr(126); # ~
  $rc .= chr(249); # \\371

  return $rc;
}
',
          '^VI\\r' => '
#
# Stub version of: ^VI\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(73); # I
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\377\\301' => '
#
# Stub version of: \\377\\301
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(193); # \\301

  return $rc;
}
',
          '\\E[?19h\\E[i' => '
#
# Stub version of: \\E[?19h\\E[i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\EY$<50>' => '
#
# Stub version of: \\EY$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?5h\\E[?5l$<6>' => '
#
# Stub version of: \\E[?5h\\E[?5l$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EY\\r' => '
#
# Stub version of: \\EY\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Ej$<30/>' => '
#
# Stub version of: \\Ej$<30/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EE$<11>' => '
#
# Stub version of: \\EE$<11>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[151q' => '
#
# Stub version of: \\E[151q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(49); # 1
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E^E01' => '
#
# Stub version of: \\E^E01
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^E
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1

  return $rc;
}
',
          '%?%p1%{2}%=%t\\E[4z%e%p1%{3}%=%t\\E[5z%e%p1%{4}%=%t\\E[6z%e%p1%{6}%=%t\\E[z%e%p1%{8}%=%t\\E[2z%e%p1%{12}%=%t\\E[3z%;' => '
#
# Stub version of: %?%p1%{2}%=%t\\E[4z%e%p1%{3}%=%t\\E[5z%e%p1%{4}%=%t\\E[6z%e%p1%{6}%=%t\\E[z%e%p1%{8}%=%t\\E[2z%e%p1%{12}%=%t\\E[3z%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 2); # %{2}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(52); # 4
    $rc .= chr(122); # z
  } # %;
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(53); # 5
    $rc .= chr(122); # z
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(54); # 6
    $rc .= chr(122); # z
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(122); # z
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 8); # %{8}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(50); # 2
    $rc .= chr(122); # z
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 12); # %{12}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(91); # [
    $rc .= chr(51); # 3
    $rc .= chr(122); # z
  }

  return $rc;
}
',
          '\\E0D\\E)' => '
#
# Stub version of: \\E0D\\E)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(68); # D
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )

  return $rc;
}
',
          '^_' => '
#
# Stub version of: ^_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^_

  return $rc;
}
',
          '\\E[35;2~' => '
#
# Stub version of: \\E[35;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '``a1fxgqh0jYk?lZm@nEooppqDrrsstCu4vAwBx3yyzz{{||}}~~' => '
#
# Stub version of: ``a1fxgqh0jYk?lZm@nEooppqDrrsstCu4vAwBx3yyzz{{||}}~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(49); # 1
  $rc .= chr(102); # f
  $rc .= chr(120); # x
  $rc .= chr(103); # g
  $rc .= chr(113); # q
  $rc .= chr(104); # h
  $rc .= chr(48); # 0
  $rc .= chr(106); # j
  $rc .= chr(89); # Y
  $rc .= chr(107); # k
  $rc .= chr(63); # ?
  $rc .= chr(108); # l
  $rc .= chr(90); # Z
  $rc .= chr(109); # m
  $rc .= chr(64); # @
  $rc .= chr(110); # n
  $rc .= chr(69); # E
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(68); # D
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(67); # C
  $rc .= chr(117); # u
  $rc .= chr(52); # 4
  $rc .= chr(118); # v
  $rc .= chr(65); # A
  $rc .= chr(119); # w
  $rc .= chr(66); # B
  $rc .= chr(120); # x
  $rc .= chr(51); # 3
  $rc .= chr(121); # y
  $rc .= chr(121); # y
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(123); # {
  $rc .= chr(123); # {
  $rc .= chr(124); # |
  $rc .= chr(124); # |
  $rc .= chr(125); # }
  $rc .= chr(125); # }
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^^D' => '
#
# Stub version of: ^^D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[1Q' => '
#
# Stub version of: \\E[1Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E[?4i' => '
#
# Stub version of: \\E[?4i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E%!0\\ELBG8\\E%!1\\E[34;1H\\E[J' => '
#
# Stub version of: \\E%!0\\ELBG8\\E%!1\\E[34;1H\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(71); # G
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[1;6Q' => '
#
# Stub version of: \\E[1;6Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\377\\275' => '
#
# Stub version of: \\377\\275
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(189); # \\275

  return $rc;
}
',
          '\\E[0p\\016' => '
#
# Stub version of: \\E[0p\\016
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(14); # \\016

  return $rc;
}
',
          '\\E[>M' => '
#
# Stub version of: \\E[>M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(77); # M

  return $rc;
}
',
          '^\\051\\r' => '
#
# Stub version of: ^\\051\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(41); # \\051
  $rc .= chr(13); # \\r

  return $rc;
}
',
          'Oa``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~' => '
#
# Stub version of: Oa``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(79); # O
  $rc .= chr(97); # a
  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(121); # y
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(123); # {
  $rc .= chr(123); # {
  $rc .= chr(124); # |
  $rc .= chr(124); # |
  $rc .= chr(125); # }
  $rc .= chr(125); # }
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EF!' => '
#
# Stub version of: \\EF!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(33); # !

  return $rc;
}
',
          '^Z8' => '
#
# Stub version of: ^Z8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Z
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\EE$<5*/>' => '
#
# Stub version of: \\EE$<5*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EL\\Eb' => '
#
# Stub version of: \\EL\\Eb
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E[10/y\\E[=1h\\E[=2l\\E[=6h' => '
#
# Stub version of: \\E[10/y\\E[=1h\\E[=2l\\E[=6h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(121); # y
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(54); # 6
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[1;2A' => '
#
# Stub version of: \\E[1;2A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\001\\001_\\001\\0' => '
#
# Stub version of: \\001\\001_\\001\\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(1); # \\001
  $rc .= chr(1); # \\001
  $rc .= chr(95); # _
  $rc .= chr(1); # \\001
  $rc .= chr(128); # \\0

  return $rc;
}
',
          '\\EO1;6C' => '
#
# Stub version of: \\EO1;6C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E~!\\E~4$<70>' => '
#
# Stub version of: \\E~!\\E~4$<70>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(52); # 4
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[4l$<80>' => '
#
# Stub version of: \\E[4l$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '%?%p1%{0}%=%t%{76}%e%p1%{1}%=%t%{64}%e%p1%{2}%=%t%{8}%e%p1%{3}%=%t%{72}%e%p1%{4}%=%t%{4}%e%p1%{5}%=%t%{68}%e%p1%{6}%=%t%{12}%e%p1%{7}%=%t%{0}%;%PC\\EG%gC%gA%+%{48}%+%c' => '
#
# Stub version of: %?%p1%{0}%=%t%{76}%e%p1%{1}%=%t%{64}%e%p1%{2}%=%t%{8}%e%p1%{3}%=%t%{72}%e%p1%{4}%=%t%{4}%e%p1%{5}%=%t%{68}%e%p1%{6}%=%t%{12}%e%p1%{7}%=%t%{0}%;%PC\\EG%gC%gA%+%{48}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    push(@iparam, 76); # %{76}
  } # %;
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 1); # %{1}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 64); # %{64}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 2); # %{2}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 8); # %{8}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 72); # %{72}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 5); # %{5}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 68); # %{68}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 12); # %{12}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 7); # %{7}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 0); # %{0}
  }
  $staticp->[2] = pop(@iparam); # %PC
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  push(@iparam, $staticp->[2]); # %gC
  push(@iparam, $staticp->[0]); # %gA
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          'PF5' => '
#
# Stub version of: PF5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(80); # P
  $rc .= chr(70); # F
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\2330m\\E(B' => '
#
# Stub version of: \\2330m\\E(B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[>59l' => '
#
# Stub version of: \\E[>59l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(57); # 9
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EG8$<10/>' => '
#
# Stub version of: \\EG8$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(56); # 8
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EFJ' => '
#
# Stub version of: \\EFJ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\377\\314' => '
#
# Stub version of: \\377\\314
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(204); # \\314

  return $rc;
}
',
          '\\E[226z' => '
#
# Stub version of: \\E[226z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[2$~\\r\\E[1$}\\E[K\\E[$}' => '
#
# Stub version of: \\E[2$~\\r\\E[1$}\\E[K\\E[$}
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(126); # ~
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(125); # }
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(36); # $
  $rc .= chr(125); # }

  return $rc;
}
',
          '\\E&r%p1%dD' => '
#
# Stub version of: \\E&r%p1%dD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(114); # r
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\23325~' => '
#
# Stub version of: \\23325~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EQ%p1%d;' => '
#
# Stub version of: \\EQ%p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\EDF\\EC\\Eb\\EG0\\Er\\EO\\E\'\\E(\\E%\\Ew\\EX\\Ee \\017\\011\\Ek\\E016\\E004\\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\011\\Ex3\\0\\0\\Ex4\\r\\0\\E\\\\3\\E-07\\s' => '
#
# Stub version of: \\EDF\\EC\\Eb\\EG0\\Er\\EO\\E\'\\E(\\E%\\Ew\\EX\\Ee \\017\\011\\Ek\\E016\\E004\\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\011\\Ex3\\0\\0\\Ex4\\r\\0\\E\\\\3\\E-07\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(32); #  
  $rc .= chr(15); # \\017
  $rc .= chr(9); # \\011
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(9); # \\011
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(52); # 4
  $rc .= chr(13); # \\r
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(45); # -
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E>\\E[?3l\\E[?7h\\E[?8h\\E[p' => '
#
# Stub version of: \\E>\\E[?3l\\E[?7h\\E[?8h\\E[p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[J$<110>' => '
#
# Stub version of: \\E[J$<110>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\017\\025\\035\\036E\\036\\022\\\\' => '
#
# Stub version of: \\017\\025\\035\\036E\\036\\022\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(21); # \\025
  $rc .= chr(29); # \\035
  $rc .= chr(30); # \\036
  $rc .= chr(69); # E
  $rc .= chr(30); # \\036
  $rc .= chr(18); # \\022
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '^^PH' => '
#
# Stub version of: ^^PH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[?7m' => '
#
# Stub version of: \\E[?7m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          'pf2' => '
#
# Stub version of: pf2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(112); # p
  $rc .= chr(102); # f
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\030\\E1\\s\\s' => '
#
# Stub version of: \\030\\E1\\s\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(24); # \\030
  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  $rc .= chr(32); # \\s
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\ENu' => '
#
# Stub version of: \\ENu
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\E<' => '
#
# Stub version of: \\E<
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <

  return $rc;
}
',
          '^^%%' => '
#
# Stub version of: ^^%%
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= \'%\';

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\E[?38h\\E8' => '
#
# Stub version of: \\E[?38h\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '~$<\\23316>' => '
#
# Stub version of: ~$<\\23316>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1D' => '
#
# Stub version of: \\E[1D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\037dli\\r\\006' => '
#
# Stub version of: \\037dli\\r\\006
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(100); # d
  $rc .= chr(108); # l
  $rc .= chr(105); # i
  $rc .= chr(13); # \\r
  $rc .= chr(6); # \\006

  return $rc;
}
',
          '\\E\\\\3\\E-07\\s' => '
#
# Stub version of: \\E\\\\3\\E-07\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(45); # -
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\Ev  \\001\\177p\\Ep\\r\\n' => '
#
# Stub version of: \\Ev  \\001\\177p\\Ep\\r\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(1); # \\001
  $rc .= chr(127); # \\177
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '^Ab\\r' => '
#
# Stub version of: ^Ab\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(98); # b
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\233?25l\\233?25h' => '
#
# Stub version of: \\233?25l\\233?25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[199z' => '
#
# Stub version of: \\E[199z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[4C' => '
#
# Stub version of: \\E[4C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(67); # C

  return $rc;
}
',
          '^TC6' => '
#
# Stub version of: ^TC6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^T
  $rc .= chr(67); # C
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\014$<12/>' => '
#
# Stub version of: \\014$<12/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERB0' => '
#
# Stub version of: \\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERBA4\\ERB0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(66); # B
  $rc .= chr(65); # A
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(66); # B
  $rc .= chr(65); # A
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(66); # B
  $rc .= chr(65); # A
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(66); # B
  $rc .= chr(65); # A
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(66); # B
  $rc .= chr(65); # A
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(66); # B
  $rc .= chr(65); # A
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(66); # B
  $rc .= chr(65); # A
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(66); # B
  $rc .= chr(65); # A
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(66); # B
  $rc .= chr(65); # A
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(66); # B
  $rc .= chr(65); # A
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(66); # B
  $rc .= chr(48); # 0

  return $rc;
}
',
          '++\\,\\,--..00``aaffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~' => '
#
# Stub version of: ++\\,\\,--..00``aaffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(43); # +
  $rc .= chr(128); # \\,
  $rc .= chr(128); # \\,
  $rc .= chr(45); # -
  $rc .= chr(45); # -
  $rc .= chr(46); # .
  $rc .= chr(46); # .
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(104); # h
  $rc .= chr(104); # h
  $rc .= chr(105); # i
  $rc .= chr(105); # i
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(121); # y
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(123); # {
  $rc .= chr(123); # {
  $rc .= chr(124); # |
  $rc .= chr(124); # |
  $rc .= chr(125); # }
  $rc .= chr(125); # }
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\036DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD\\037' => '
#
# Stub version of: \\036DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD\\037
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(68); # D
  $rc .= chr(31); # \\037

  return $rc;
}
',
          '\\EH$<1>' => '
#
# Stub version of: \\EH$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\r\\n\\E[A\\E7\\E[255;1;0;76;89;100p\\E8\\E[J' => '
#
# Stub version of: \\r\\n\\E[A\\E7\\E[255;1;0;76;89;100p\\E8\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E$Q' => '
#
# Stub version of: \\E$Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E[207z' => '
#
# Stub version of: \\E[207z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\377' => '
#
# Stub version of: \\377
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377

  return $rc;
}
',
          '\\E.' => '
#
# Stub version of: \\E.
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(46); # .

  return $rc;
}
',
          '\\E[201z' => '
#
# Stub version of: \\E[201z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\377\\245' => '
#
# Stub version of: \\377\\245
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(165); # \\245

  return $rc;
}
',
          '\\032$<2>' => '
#
# Stub version of: \\032$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(26); # \\032
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[8~' => '
#
# Stub version of: \\E[8~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^AH\\r' => '
#
# Stub version of: ^AH\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(72); # H
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EF+' => '
#
# Stub version of: \\EF+
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(43); # +

  return $rc;
}
',
          '\\E[%?%p4%t5;%;%?%p2%p6%|%t4;%;%?%p1%p5%|%t2;%;%?%p1%p3%|%p6%|%t7;%;m' => '
#
# Stub version of: \\E[%?%p4%t5;%;%?%p2%p6%|%t4;%;%?%p1%p5%|%t2;%;%?%p1%p3%|%p6%|%t7;%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          'TABSET' => '
#
# Stub version of: TABSET
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(84); # T
  $rc .= chr(65); # A
  $rc .= chr(66); # B
  $rc .= chr(83); # S
  $rc .= chr(69); # E
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\Eg\\Ef\\r\\Ed' => '
#
# Stub version of: \\Eg\\Ef\\r\\Ed
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\E[1;6C' => '
#
# Stub version of: \\E[1;6C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[1;24r\\E[24;1H' => '
#
# Stub version of: \\E[1;24r\\E[24;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          'LEFT' => '
#
# Stub version of: LEFT
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(76); # L
  $rc .= chr(69); # E
  $rc .= chr(70); # F
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\ER@' => '
#
# Stub version of: \\ER@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\233007z' => '
#
# Stub version of: \\233007z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\ENv' => '
#
# Stub version of: \\ENv
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\E[028q' => '
#
# Stub version of: \\E[028q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[[C' => '
#
# Stub version of: \\E[[C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E\\001\\E8' => '
#
# Stub version of: \\E\\001\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[5;4~' => '
#
# Stub version of: \\E[5;4~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '%?%p1%{0}%=%t%{49}%e%p1%{1}%=%t%{50}%e%p1%{2}%=%t%{51}%e%p1%{3}%=%t%{52}%e%p1%{4}%=%t%{53}%e%p1%{5}%=%t%{54}%e%p1%{6}%=%t%{55}%e%p1%{7}%=%t%{64}%e%p1%{8}%=%t%{57}%e%p1%{9}%=%t%{58}%e%p1%{10}%=%t%{59}%e%p1%{11}%=%t%{60}%e%p1%{12}%=%t%{61}%e%p1%{13}%=%t%{62}%e%p1%{14}%=%t%{63}%e%p1%{15}%=%t%{56}%;\\Edy%c11$<100>' => '
#
# Stub version of: %?%p1%{0}%=%t%{49}%e%p1%{1}%=%t%{50}%e%p1%{2}%=%t%{51}%e%p1%{3}%=%t%{52}%e%p1%{4}%=%t%{53}%e%p1%{5}%=%t%{54}%e%p1%{6}%=%t%{55}%e%p1%{7}%=%t%{64}%e%p1%{8}%=%t%{57}%e%p1%{9}%=%t%{58}%e%p1%{10}%=%t%{59}%e%p1%{11}%=%t%{60}%e%p1%{12}%=%t%{61}%e%p1%{13}%=%t%{62}%e%p1%{14}%=%t%{63}%e%p1%{15}%=%t%{56}%;\\Edy%c11$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    push(@iparam, 49); # %{49}
  } # %;
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 1); # %{1}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 50); # %{50}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 2); # %{2}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 51); # %{51}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 52); # %{52}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 53); # %{53}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 5); # %{5}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 54); # %{54}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 55); # %{55}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 7); # %{7}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 64); # %{64}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 8); # %{8}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 57); # %{57}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 9); # %{9}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 58); # %{58}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 10); # %{10}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 59); # %{59}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 11); # %{11}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 60); # %{60}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 12); # %{12}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 61); # %{61}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 13); # %{13}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 62); # %{62}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 14); # %{14}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 63); # %{63}
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 15); # %{15}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    push(@iparam, 56); # %{56}
  }
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(121); # y
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EZ' => '
#
# Stub version of: \\EZ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\ENa' => '
#
# Stub version of: \\ENa
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\EE$<2>' => '
#
# Stub version of: \\EE$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EPY99\\:98\\E\\\\\\E[0;98v\\E[2;7m' => '
#
# Stub version of: \\EPY99\\:98\\E\\\\\\E[0;98v\\E[2;7m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(89); # Y
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\:
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[P$<1>' => '
#
# Stub version of: \\E[P$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[H\\E[J$<156>' => '
#
# Stub version of: \\E[H\\E[J$<156>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%p1%da' => '
#
# Stub version of: \\E[%p1%da
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\EX%p1%{32}%+%c\\EY%p2%{32}%+%c' => '
#
# Stub version of: \\EX%p1%{32}%+%c\\EY%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '$<1>' => '
#
# Stub version of: $<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\037com 33\\r' => '
#
# Stub version of: \\037com 33\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(99); # c
  $rc .= chr(111); # o
  $rc .= chr(109); # m
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E\'L' => '
#
# Stub version of: \\E\'L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\ERG' => '
#
# Stub version of: \\ERG
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\013$<4*/>' => '
#
# Stub version of: \\013$<4*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%p1%d@$<4/>' => '
#
# Stub version of: \\E[%p1%d@$<4/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(64); # @
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&a%p1%2dC' => '
#
# Stub version of: \\E&a%p1%2dC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[142q' => '
#
# Stub version of: \\E[142q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\377\\222' => '
#
# Stub version of: \\377\\222
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(146); # \\222

  return $rc;
}
',
          '\\E[>1h' => '
#
# Stub version of: \\E[>1h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[6;6~' => '
#
# Stub version of: \\E[6;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\217u' => '
#
# Stub version of: \\217u
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\Ej!' => '
#
# Stub version of: \\Ej!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(33); # !

  return $rc;
}
',
          '^_\\s' => '
#
# Stub version of: ^_\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^_
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E@0\\E[?4r' => '
#
# Stub version of: \\E@0\\E[?4r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(64); # @
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\Ee6\\E~%$<100>\\E+\\E`\\:\\Ed/\\E`1\\EO\\Ee4\\Ec@0@\\Ec@1A\\EcB0\\EcC1\\Ee7$<100>' => '
#
# Stub version of: \\Ee6\\E~%$<100>\\E+\\E`\\:\\Ed/\\E`1\\EO\\Ee4\\Ec@0@\\Ec@1A\\EcB0\\EcC1\\Ee7$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(37); # %
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(64); # @
  $rc .= chr(48); # 0
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(64); # @
  $rc .= chr(49); # 1
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(66); # B
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(67); # C
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(55); # 7
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[017q' => '
#
# Stub version of: \\E[017q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\233B' => '
#
# Stub version of: \\233B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[113z' => '
#
# Stub version of: \\E[113z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E&q3t0{0H \\E&w0f118n1I \\E&w0f1n2I \\E&w2f1i0d0u23l0S \\E&w3f2I \\E&w7f2p1I \\r' => '
#
# Stub version of: \\E&q3t0{0H \\E&w0f118n1I \\E&w0f1n2I \\E&w2f1i0d0u23l0S \\E&w3f2I \\E&w7f2p1I \\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(113); # q
  $rc .= chr(51); # 3
  $rc .= chr(116); # t
  $rc .= chr(48); # 0
  $rc .= chr(123); # {
  $rc .= chr(48); # 0
  $rc .= chr(72); # H
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(48); # 0
  $rc .= chr(102); # f
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(110); # n
  $rc .= chr(49); # 1
  $rc .= chr(73); # I
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(48); # 0
  $rc .= chr(102); # f
  $rc .= chr(49); # 1
  $rc .= chr(110); # n
  $rc .= chr(50); # 2
  $rc .= chr(73); # I
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(50); # 2
  $rc .= chr(102); # f
  $rc .= chr(49); # 1
  $rc .= chr(105); # i
  $rc .= chr(48); # 0
  $rc .= chr(100); # d
  $rc .= chr(48); # 0
  $rc .= chr(117); # u
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(48); # 0
  $rc .= chr(83); # S
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(51); # 3
  $rc .= chr(102); # f
  $rc .= chr(50); # 2
  $rc .= chr(73); # I
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(55); # 7
  $rc .= chr(102); # f
  $rc .= chr(50); # 2
  $rc .= chr(112); # p
  $rc .= chr(49); # 1
  $rc .= chr(73); # I
  $rc .= chr(32); #  
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[=R' => '
#
# Stub version of: \\E[=R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E&dA%{1}%PA' => '
#
# Stub version of: \\E&dA%{1}%PA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(65); # A
  push(@iparam, 1); # %{1}
  $staticp->[0] = pop(@iparam); # %PA

  return $rc;
}
',
          '\\010\\EMG1_\\EMG0' => '
#
# Stub version of: \\010\\EMG1_\\EMG0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(71); # G
  $rc .= chr(49); # 1
  $rc .= chr(95); # _
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(71); # G
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\036P@1' => '
#
# Stub version of: \\036P@1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(80); # P
  $rc .= chr(64); # @
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[1;28r\\E[28;1H' => '
#
# Stub version of: \\E[1;28r\\E[28;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\EU\\EX\\EU\\EX\\EU\\EX\\EU\\EX' => '
#
# Stub version of: \\EU\\EX\\EU\\EX\\EU\\EX\\EU\\EX
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X

  return $rc;
}
',
          '\\E~' => '
#
# Stub version of: \\E~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E\\023\\E4' => '
#
# Stub version of: \\E\\023\\E4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\'x+y.w_vi~j(k\'l&m%n)o9q*s8t-u.v\\,w+x=' => '
#
# Stub version of: \'x+y.w_vi~j(k\'l&m%n)o9q*s8t-u.v\\,w+x=
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(39); # \'
  $rc .= chr(120); # x
  $rc .= chr(43); # +
  $rc .= chr(121); # y
  $rc .= chr(46); # .
  $rc .= chr(119); # w
  $rc .= chr(95); # _
  $rc .= chr(118); # v
  $rc .= chr(105); # i
  $rc .= chr(126); # ~
  $rc .= chr(106); # j
  $rc .= chr(40); # (
  $rc .= chr(107); # k
  $rc .= chr(39); # \'
  $rc .= chr(108); # l
  $rc .= chr(38); # &
  $rc .= chr(109); # m
  $rc .= chr(37); # %
  $rc .= chr(110); # n
  $rc .= chr(41); # )
  $rc .= chr(111); # o
  $rc .= chr(57); # 9
  $rc .= chr(113); # q
  $rc .= chr(42); # *
  $rc .= chr(115); # s
  $rc .= chr(56); # 8
  $rc .= chr(116); # t
  $rc .= chr(45); # -
  $rc .= chr(117); # u
  $rc .= chr(46); # .
  $rc .= chr(118); # v
  $rc .= chr(128); # \\,
  $rc .= chr(119); # w
  $rc .= chr(43); # +
  $rc .= chr(120); # x
  $rc .= chr(61); # =

  return $rc;
}
',
          '\\EDF\\EC\\Eg\\Er\\EO\\E\'\\E(\\Ew\\EX\\Ee \\017\\E0P\\E6\\0\\E0p\\E4\\0\\Ef\\r' => '
#
# Stub version of: \\EDF\\EC\\Eg\\Er\\EO\\E\'\\E(\\Ew\\EX\\Ee \\017\\E0P\\E6\\0\\E0p\\E4\\0\\Ef\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(32); #  
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(80); # P
  $rc .= chr(27); # \\E
  $rc .= chr(54); # 6
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Ec' => '
#
# Stub version of: \\Ec
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\0T' => '
#
# Stub version of: \\0T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\E[63;2"p\\E[2h' => '
#
# Stub version of: \\E[63;2"p\\E[2h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EO\\Ee' => '
#
# Stub version of: \\EO\\Ee
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\EI$<15>' => '
#
# Stub version of: \\EI$<15>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '^B2\\r' => '
#
# Stub version of: ^B2\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(50); # 2
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[K$<3/>' => '
#
# Stub version of: \\E[K$<3/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '^NF' => '
#
# Stub version of: ^NF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^N
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\EM$<3*/>' => '
#
# Stub version of: \\EM$<3*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1;4B' => '
#
# Stub version of: \\E[1;4B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(66); # B

  return $rc;
}
',
          '^A<1' => '
#
# Stub version of: ^A<1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(60); # <
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[16r' => '
#
# Stub version of: \\E[16r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[%p1%dP$<4/>' => '
#
# Stub version of: \\E[%p1%dP$<4/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?1h' => '
#
# Stub version of: \\E[?1h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EP$<50>' => '
#
# Stub version of: \\EP$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO3C' => '
#
# Stub version of: \\EO3C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(51); # 3
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E$\\E\\005\\E?\\E\\031' => '
#
# Stub version of: \\E$\\E\\005\\E?\\E\\031
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(27); # \\E
  $rc .= chr(5); # \\005
  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(27); # \\E
  $rc .= chr(25); # \\031

  return $rc;
}
',
          '\\E[2;7m' => '
#
# Stub version of: \\E[2;7m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EE$<5>' => '
#
# Stub version of: \\EE$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%?%p1%{8}%>%t%\'2\'%p1%+%d%e3%p1%d%;m' => '
#
# Stub version of: \\E[%?%p1%{8}%>%t%\'2\'%p1%+%d%e3%p1%d%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 8); # %{8}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, chr(50)); # %\'2\'
    push(@iparam, $param[0]); # %p1
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  }
  else { # %e
    $rc .= chr(51); # 3
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\024%p1%c%p2%c' => '
#
# Stub version of: \\024%p1%c%p2%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(20); # \\024
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '~\\021%p2%c%p1%c' => '
#
# Stub version of: ~\\021%p2%c%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(17); # \\021
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\377\\270' => '
#
# Stub version of: \\377\\270
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(184); # \\270

  return $rc;
}
',
          '\\E[%p1%dL$<80>' => '
#
# Stub version of: \\E[%p1%dL$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\233107z' => '
#
# Stub version of: \\233107z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E&a%p1%dR' => '
#
# Stub version of: \\E&a%p1%dR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\EF\\Ef0;\\Eb0;' => '
#
# Stub version of: \\EF\\Ef0;\\Eb0;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[7;31m' => '
#
# Stub version of: \\E[7;31m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\036FA\\036FT0' => '
#
# Stub version of: \\036FA\\036FT0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(65); # A
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(84); # T
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\Eb\\ED' => '
#
# Stub version of: \\Eb\\ED
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(68); # D

  return $rc;
}
',
          '^Z1' => '
#
# Stub version of: ^Z1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Z
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[=103h\\E[=205l' => '
#
# Stub version of: \\E[=103h\\E[=205l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '^CP' => '
#
# Stub version of: ^CP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^C
  $rc .= chr(80); # P

  return $rc;
}
',
          '^P^Z' => '
#
# Stub version of: ^P^Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(0); # ^Z

  return $rc;
}
',
          '\\Ew\\r' => '
#
# Stub version of: \\Ew\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[4u\\027' => '
#
# Stub version of: \\E[4u\\027
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(117); # u
  $rc .= chr(23); # \\027

  return $rc;
}
',
          '\\E[5B' => '
#
# Stub version of: \\E[5B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(66); # B

  return $rc;
}
',
          '^^O' => '
#
# Stub version of: ^^O
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\E[?1l\\E>$<10/>' => '
#
# Stub version of: \\E[?1l\\E>$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ej\\EYI%+ \\Eo' => '
#
# Stub version of: \\Ej\\EYI%+ \\Eo
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(73); # I
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\E^O' => '
#
# Stub version of: \\E^O
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^O

  return $rc;
}
',
          '+\\253\\,\\273-\\030.\\031`\\201a\\202f\\207g\\210i\\247j\\213k\\214l\\215m\\216n\\217o\\220p\\221q\\222r\\223s\\224t\\225u\\226v\\227w\\230x\\231y\\232z\\233~\\237' => '
#
# Stub version of: +\\253\\,\\273-\\030.\\031`\\201a\\202f\\207g\\210i\\247j\\213k\\214l\\215m\\216n\\217o\\220p\\221q\\222r\\223s\\224t\\225u\\226v\\227w\\230x\\231y\\232z\\233~\\237
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(171); # \\253
  $rc .= chr(128); # \\,
  $rc .= chr(187); # \\273
  $rc .= chr(45); # -
  $rc .= chr(24); # \\030
  $rc .= chr(46); # .
  $rc .= chr(25); # \\031
  $rc .= chr(96); # `
  $rc .= chr(129); # \\201
  $rc .= chr(97); # a
  $rc .= chr(130); # \\202
  $rc .= chr(102); # f
  $rc .= chr(135); # \\207
  $rc .= chr(103); # g
  $rc .= chr(136); # \\210
  $rc .= chr(105); # i
  $rc .= chr(167); # \\247
  $rc .= chr(106); # j
  $rc .= chr(139); # \\213
  $rc .= chr(107); # k
  $rc .= chr(140); # \\214
  $rc .= chr(108); # l
  $rc .= chr(141); # \\215
  $rc .= chr(109); # m
  $rc .= chr(142); # \\216
  $rc .= chr(110); # n
  $rc .= chr(143); # \\217
  $rc .= chr(111); # o
  $rc .= chr(144); # \\220
  $rc .= chr(112); # p
  $rc .= chr(145); # \\221
  $rc .= chr(113); # q
  $rc .= chr(146); # \\222
  $rc .= chr(114); # r
  $rc .= chr(147); # \\223
  $rc .= chr(115); # s
  $rc .= chr(148); # \\224
  $rc .= chr(116); # t
  $rc .= chr(149); # \\225
  $rc .= chr(117); # u
  $rc .= chr(150); # \\226
  $rc .= chr(118); # v
  $rc .= chr(151); # \\227
  $rc .= chr(119); # w
  $rc .= chr(152); # \\230
  $rc .= chr(120); # x
  $rc .= chr(153); # \\231
  $rc .= chr(121); # y
  $rc .= chr(154); # \\232
  $rc .= chr(122); # z
  $rc .= chr(155); # \\233
  $rc .= chr(126); # ~
  $rc .= chr(159); # \\237

  return $rc;
}
',
          '\\E[=0;<1m\\E[24;25;27m\\017' => '
#
# Stub version of: \\E[=0;<1m\\E[24;25;27m\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\E>A' => '
#
# Stub version of: \\E>A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[%p1%dA$<30>' => '
#
# Stub version of: \\E[%p1%dA$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(65); # A
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p4%t;5%;%?%p1%p3%|%t;7%;m%?%p9%t\\E(0%e\\E(B%;' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p4%t;5%;%?%p1%p3%|%t;7%;m%?%p9%t\\E(0%e\\E(B%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;

  return $rc;
}
',
          '\\E[m\\E[p' => '
#
# Stub version of: \\E[m\\E[p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[%p1%dX$<.1*>' => '
#
# Stub version of: \\E[%p1%dX$<.1*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(88); # X
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(46); # .
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[20h' => '
#
# Stub version of: \\E[20h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\2339~' => '
#
# Stub version of: \\2339~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(57); # 9
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E&a+%p1%dC' => '
#
# Stub version of: \\E&a+%p1%dC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  $rc .= chr(43); # +
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C

  return $rc;
}
',
          '~^Y' => '
#
# Stub version of: ~^Y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(0); # ^Y

  return $rc;
}
',
          '\\EF15' => '
#
# Stub version of: \\EF15
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5

  return $rc;
}
',
          '^A2\\r' => '
#
# Stub version of: ^A2\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(50); # 2
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^^\\s' => '
#
# Stub version of: ^^\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\377\\327' => '
#
# Stub version of: \\377\\327
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(215); # \\327

  return $rc;
}
',
          '\\233%p1%dP' => '
#
# Stub version of: \\233%p1%dP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(80); # P

  return $rc;
}
',
          '^^{' => '
#
# Stub version of: ^^{
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(123); # {

  return $rc;
}
',
          '^Ax\\r' => '
#
# Stub version of: ^Ax\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(120); # x
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[1P$<5>' => '
#
# Stub version of: \\E[1P$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%gh%{8}%^%Ph%gh%dZZ' => '
#
# Stub version of: \\E[%gh%{8}%^%Ph%gh%dZZ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $dynamicp->[7]); # %gh
  push(@iparam, 8); # %{8}
  push(@iparam, pop(@iparam) ^ pop(@iparam)); # %^
  $dynamicp->[7] = pop(@iparam); # %Ph
  push(@iparam, $dynamicp->[7]); # %gh
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(90); # Z
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\017\\E0P' => '
#
# Stub version of: \\017\\E0P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[4h' => '
#
# Stub version of: \\E[4h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[20l\\E[?7h' => '
#
# Stub version of: \\E[20l\\E[?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[00s' => '
#
# Stub version of: \\E[00s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\Ey$<50>' => '
#
# Stub version of: \\Ey$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[3%p1%{8}%m%d%?%p1%{7}%>%t;1%e;21%;m' => '
#
# Stub version of: \\E[3%p1%{8}%m%d%?%p1%{7}%>%t;1%e;21%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  push(@iparam, $param[0]); # %p1
  push(@iparam, 8); # %{8}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 7); # %{7}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  }
  else { # %e
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EP\\EE0;0;' => '
#
# Stub version of: \\EP\\EE0;0;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[12r' => '
#
# Stub version of: \\E[12r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[m\\017\\E[1;2;3;4;6l\\E[12;13;14;20l\\E[?6;97;99l\\E[?7h\\E[4i\\Ex\\E[21;1j\\212' => '
#
# Stub version of: \\E[m\\017\\E[1;2;3;4;6l\\E[12;13;14;20l\\E[?6;97;99l\\E[?7h\\E[4i\\Ex\\E[21;1j\\212
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(105); # i
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(138); # \\212

  return $rc;
}
',
          '\\E[h' => '
#
# Stub version of: \\E[h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[10r' => '
#
# Stub version of: \\E[10r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\Ep' => '
#
# Stub version of: \\Ep
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[2\\^' => '
#
# Stub version of: \\E[2\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '^AE\\r' => '
#
# Stub version of: ^AE\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(69); # E
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[?1h\\E=' => '
#
# Stub version of: \\E[?1h\\E=
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =

  return $rc;
}
',
          '\\2337m' => '
#
# Stub version of: \\2337m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EO1;4C' => '
#
# Stub version of: \\EO1;4C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[v' => '
#
# Stub version of: \\E[v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;m' => '
#
# Stub version of: \\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          'PF2' => '
#
# Stub version of: PF2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(80); # P
  $rc .= chr(70); # F
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E[!z\\E[0;2u' => '
#
# Stub version of: \\E[!z\\E[0;2u
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(122); # z
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\EFm' => '
#
# Stub version of: \\EFm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[21;2~' => '
#
# Stub version of: \\E[21;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[=205l$<200>\\E[=205h' => '
#
# Stub version of: \\E[=205l$<200>\\E[=205h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E^A' => '
#
# Stub version of: \\E^A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^A

  return $rc;
}
',
          '\\E[?5l\\E[48*|\\E[48t\\E[40l\\E[1;48r' => '
#
# Stub version of: \\E[?5l\\E[48*|\\E[48t\\E[40l\\E[1;48r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(42); # *
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(116); # t
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(114); # r

  return $rc;
}
',
          '``aaffggjjkkllmmnnooqqssttuuvvwwxx{{||}}~~' => '
#
# Stub version of: ``aaffggjjkkllmmnnooqqssttuuvvwwxx{{||}}~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(123); # {
  $rc .= chr(123); # {
  $rc .= chr(124); # |
  $rc .= chr(124); # |
  $rc .= chr(125); # }
  $rc .= chr(125); # }
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\233 @' => '
#
# Stub version of: \\233 @
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(32); #  
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\EOC' => '
#
# Stub version of: \\EOC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[60;0;0;36p\\E[36;1H\\E[K' => '
#
# Stub version of: \\E[60;0;0;36p\\E[36;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E[?>h\\EPY99\\:98\\E\\\\' => '
#
# Stub version of: \\E[?>h\\EPY99\\:98\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(62); # >
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(89); # Y
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\:
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E|%p1%{48}%+%c3%p2%s\\031' => '
#
# Stub version of: \\E|%p1%{48}%+%c3%p2%s\\031
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(124); # |
  push(@iparam, $param[0]); # %p1
  push(@iparam, 48); # %{48}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(51); # 3
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(25); # \\031

  return $rc;
}
',
          '\\037jum%i%p1%d\\,%p2%d;' => '
#
# Stub version of: \\037jum%i%p1%d\\,%p2%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(106); # j
  $rc .= chr(117); # u
  $rc .= chr(109); # m
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(128); # \\,
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\ENk' => '
#
# Stub version of: \\ENk
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(107); # k

  return $rc;
}
',
          '^^=' => '
#
# Stub version of: ^^=
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(61); # =

  return $rc;
}
',
          '\\E0$<15>' => '
#
# Stub version of: \\E0$<15>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%p1%d@$<2>' => '
#
# Stub version of: \\E[%p1%d@$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(64); # @
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[11;3~' => '
#
# Stub version of: \\E[11;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[20s' => '
#
# Stub version of: \\E[20s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E[8;0|\\E[?3;4;5;13;15l\\E[13;20l\\E[?7h\\E[12h\\E(B\\E)0' => '
#
# Stub version of: \\E[8;0|\\E[?3;4;5;13;15l\\E[13;20l\\E[?7h\\E[12h\\E(B\\E)0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[;;;;;;;;;2;;u$<200/>\\E[;;;;;;;;;1;;u' => '
#
# Stub version of: \\E[;;;;;;;;;2;;u$<200/>\\E[;;;;;;;;;1;;u
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(117); # u
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(59); # ;
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\E[1;7D' => '
#
# Stub version of: \\E[1;7D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[2;1!w\\E[;%p1%dH\\E[2K' => '
#
# Stub version of: \\E[2;1!w\\E[;%p1%dH\\E[2K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(33); # !
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\EF06' => '
#
# Stub version of: \\EF06
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E[26\\^' => '
#
# Stub version of: \\E[26\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\Et' => '
#
# Stub version of: \\Et
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\233?1h\\E=' => '
#
# Stub version of: \\233?1h\\E=
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =

  return $rc;
}
',
          '\\E[00u\\E[<>001001024080024080u\\E[01u' => '
#
# Stub version of: \\E[00u\\E[<>001001024080024080u\\E[01u
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(62); # >
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\E\\^1$<30/>\\E\\^0' => '
#
# Stub version of: \\E\\^1$<30/>\\E\\^0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[66;%p1%d;%?%p2%{250}%<%t%{0}%e%p2%{500}%<%t%{16}%e%p2%{750}%<%t%{32}%e%{48}%;%?%p3%{250}%<%t%{0}%e%p3%{500}%<%t%{4}%e%p3%{750}%<%t%{8}%e%{12}%;%?%p4%{250}%<%t%{0}%e%p4%{500}%<%t%{1}%e%p4%{750}%<%t%{2}%e%{3}%;%{1}%+%+%+%dw' => '
#
# Stub version of: \\E[66;%p1%d;%?%p2%{250}%<%t%{0}%e%p2%{500}%<%t%{16}%e%p2%{750}%<%t%{32}%e%{48}%;%?%p3%{250}%<%t%{0}%e%p3%{500}%<%t%{4}%e%p3%{750}%<%t%{8}%e%{12}%;%?%p4%{250}%<%t%{0}%e%p4%{500}%<%t%{1}%e%p4%{750}%<%t%{2}%e%{3}%;%{1}%+%+%+%dw
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, 250); # %{250}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    push(@iparam, 0); # %{0}
  }
  elsif (do { # %e
              push(@iparam, $param[1]); # %p2
              push(@iparam, 500); # %{500}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    push(@iparam, 16); # %{16}
  }
  elsif (do { # %e
              push(@iparam, $param[1]); # %p2
              push(@iparam, 750); # %{750}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    push(@iparam, 32); # %{32}
  }
  else { # %e
    push(@iparam, 48); # %{48}
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, 250); # %{250}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    push(@iparam, 0); # %{0}
  }
  elsif (do { # %e
              push(@iparam, $param[2]); # %p3
              push(@iparam, 500); # %{500}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
  }
  elsif (do { # %e
              push(@iparam, $param[2]); # %p3
              push(@iparam, 750); # %{750}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    push(@iparam, 8); # %{8}
  }
  else { # %e
    push(@iparam, 12); # %{12}
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           push(@iparam, 250); # %{250}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    push(@iparam, 0); # %{0}
  }
  elsif (do { # %e
              push(@iparam, $param[3]); # %p4
              push(@iparam, 500); # %{500}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
  }
  elsif (do { # %e
              push(@iparam, $param[3]); # %p4
              push(@iparam, 750); # %{750}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
  }
  else { # %e
    push(@iparam, 3); # %{3}
  } # %;
  push(@iparam, 1); # %{1}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(119); # w

  return $rc;
}
',
          '^VH\\r' => '
#
# Stub version of: ^VH\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(72); # H
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Eb$<200/>\\Ed' => '
#
# Stub version of: \\Eb$<200/>\\Ed
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\0]' => '
#
# Stub version of: \\0]
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(93); # ]

  return $rc;
}
',
          '\\E[0s' => '
#
# Stub version of: \\E[0s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E];' => '
#
# Stub version of: \\E];
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[OS' => '
#
# Stub version of: \\E[OS
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(79); # O
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E[27s' => '
#
# Stub version of: \\E[27s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(115); # s

  return $rc;
}
',
          'home' => '
#
# Stub version of: home
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(104); # h
  $rc .= chr(111); # o
  $rc .= chr(109); # m
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\E"I' => '
#
# Stub version of: \\E"I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\EO5R' => '
#
# Stub version of: \\EO5R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(53); # 5
  $rc .= chr(82); # R

  return $rc;
}
',
          '^]7`x @\\037' => '
#
# Stub version of: ^]7`x @\\037
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^]
  $rc .= chr(55); # 7
  $rc .= chr(96); # `
  $rc .= chr(120); # x
  $rc .= chr(32); #  
  $rc .= chr(64); # @
  $rc .= chr(31); # \\037

  return $rc;
}
',
          '\\E[018q' => '
#
# Stub version of: \\E[018q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[4;7m' => '
#
# Stub version of: \\E[4;7m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EOw' => '
#
# Stub version of: \\EOw
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\E[0m' => '
#
# Stub version of: \\E[0m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[107z' => '
#
# Stub version of: \\E[107z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E7F7' => '
#
# Stub version of: \\E7F7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(70); # F
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\E[2;4;20;30;40l\\E[?1;10;16l\\E[12h\\E[?7;8;25h' => '
#
# Stub version of: \\E[2;4;20;30;40l\\E[?1;10;16l\\E[12h\\E[?7;8;25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[7~' => '
#
# Stub version of: \\E[7~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^A|' => '
#
# Stub version of: ^A|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(124); # |

  return $rc;
}
',
          '^Nu' => '
#
# Stub version of: ^Nu
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^N
  $rc .= chr(117); # u

  return $rc;
}
',
          '0wa_h[jukslrmqnxqzttuyv]wpxv' => '
#
# Stub version of: 0wa_h[jukslrmqnxqzttuyv]wpxv
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(48); # 0
  $rc .= chr(119); # w
  $rc .= chr(97); # a
  $rc .= chr(95); # _
  $rc .= chr(104); # h
  $rc .= chr(91); # [
  $rc .= chr(106); # j
  $rc .= chr(117); # u
  $rc .= chr(107); # k
  $rc .= chr(115); # s
  $rc .= chr(108); # l
  $rc .= chr(114); # r
  $rc .= chr(109); # m
  $rc .= chr(113); # q
  $rc .= chr(110); # n
  $rc .= chr(120); # x
  $rc .= chr(113); # q
  $rc .= chr(122); # z
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(121); # y
  $rc .= chr(118); # v
  $rc .= chr(93); # ]
  $rc .= chr(119); # w
  $rc .= chr(112); # p
  $rc .= chr(120); # x
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\EG0\\E%%\\E(' => '
#
# Stub version of: \\EG0\\E%%\\E(
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= \'%\';
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (

  return $rc;
}
',
          '\\EOn' => '
#
# Stub version of: \\EOn
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\E"2' => '
#
# Stub version of: \\E"2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\Ef2' => '
#
# Stub version of: \\Ef2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E&v0m1a0b0c1x1y1z1i0a0b1c1x1y1z0i0S\\E&j@\\r\\E3\\r' => '
#
# Stub version of: \\E&v0m1a0b0c1x1y1z1i0a0b1c1x1y1z0i0S\\E&j@\\r\\E3\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(49); # 1
  $rc .= chr(97); # a
  $rc .= chr(48); # 0
  $rc .= chr(98); # b
  $rc .= chr(48); # 0
  $rc .= chr(99); # c
  $rc .= chr(49); # 1
  $rc .= chr(120); # x
  $rc .= chr(49); # 1
  $rc .= chr(121); # y
  $rc .= chr(49); # 1
  $rc .= chr(122); # z
  $rc .= chr(49); # 1
  $rc .= chr(105); # i
  $rc .= chr(48); # 0
  $rc .= chr(97); # a
  $rc .= chr(48); # 0
  $rc .= chr(98); # b
  $rc .= chr(49); # 1
  $rc .= chr(99); # c
  $rc .= chr(49); # 1
  $rc .= chr(120); # x
  $rc .= chr(49); # 1
  $rc .= chr(121); # y
  $rc .= chr(49); # 1
  $rc .= chr(122); # z
  $rc .= chr(48); # 0
  $rc .= chr(105); # i
  $rc .= chr(48); # 0
  $rc .= chr(83); # S
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(106); # j
  $rc .= chr(64); # @
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%p1%dY' => '
#
# Stub version of: \\E[%p1%dY
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(89); # Y

  return $rc;
}
',
          '\\EW$<30>' => '
#
# Stub version of: \\EW$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[29;2~' => '
#
# Stub version of: \\E[29;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\2335~' => '
#
# Stub version of: \\2335~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[0%?%p1%t;2;7%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;30;1%;%?%p6%t;1%;m' => '
#
# Stub version of: \\E[0%?%p1%t;2;7%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;30;1%;%?%p6%t;1%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(51); # 3
    $rc .= chr(48); # 0
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[0@' => '
#
# Stub version of: \\E[0@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\EM$' => '
#
# Stub version of: \\EM$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\E[9r' => '
#
# Stub version of: \\E[9r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\014$<1>' => '
#
# Stub version of: \\014$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[14;6~' => '
#
# Stub version of: \\E[14;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\020\\n\\030\\035\\030\\035$<1*/>' => '
#
# Stub version of: \\020\\n\\030\\035\\030\\035$<1*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  $rc .= chr(10); # \\n
  $rc .= chr(24); # \\030
  $rc .= chr(29); # \\035
  $rc .= chr(24); # \\030
  $rc .= chr(29); # \\035
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\r\\n$<2>' => '
#
# Stub version of: \\r\\n$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\020\\177%p1%c' => '
#
# Stub version of: \\020\\177%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  $rc .= chr(127); # \\177
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\EsI' => '
#
# Stub version of: \\EsI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\E[?5i' => '
#
# Stub version of: \\E[?5i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E&a-%p1%dR' => '
#
# Stub version of: \\E&a-%p1%dR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  $rc .= chr(45); # -
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\EE$<3>' => '
#
# Stub version of: \\EE$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E)0\\E<\\EP\\E\'0\\E$2' => '
#
# Stub version of: \\E)0\\E<\\EP\\E\'0\\E$2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\EN{' => '
#
# Stub version of: \\EN{
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(123); # {

  return $rc;
}
',
          '\\016@\\026$<6>' => '
#
# Stub version of: \\016@\\026$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  $rc .= chr(64); # @
  $rc .= chr(22); # \\026
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E4$a' => '
#
# Stub version of: \\E4$a
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(36); # $
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\E[15;2~' => '
#
# Stub version of: \\E[15;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EG4$<10/>' => '
#
# Stub version of: \\EG4$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(52); # 4
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\217C' => '
#
# Stub version of: \\217C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[H\\E[2J$<6>' => '
#
# Stub version of: \\E[H\\E[2J$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?1l' => '
#
# Stub version of: \\E[?1l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\ER1;' => '
#
# Stub version of: \\ER1;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\EcD\\E\'\\Er\\EH\\003\\Ed/\\EO\\Ee1\\Ed*\\E`@\\E`9\\E`1\\016\\024\\El' => '
#
# Stub version of: \\EcD\\E\'\\Er\\EH\\003\\Ed/\\EO\\Ee1\\Ed*\\E`@\\E`9\\E`1\\016\\024\\El
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(68); # D
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1
  $rc .= chr(14); # \\016
  $rc .= chr(20); # \\024
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[?1l\\E=' => '
#
# Stub version of: \\E[?1l\\E=
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =

  return $rc;
}
',
          'U2 PC-DOS 3.1 ANSI.SYS with keypad redefined for vi 9-29-86\\n\\E[;75;8p' => '
#
# Stub version of: U2 PC-DOS 3.1 ANSI.SYS with keypad redefined for vi 9-29-86\\n\\E[;75;8p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(85); # U
  $rc .= chr(50); # 2
  $rc .= chr(32); #  
  $rc .= chr(80); # P
  $rc .= chr(67); # C
  $rc .= chr(45); # -
  $rc .= chr(68); # D
  $rc .= chr(79); # O
  $rc .= chr(83); # S
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(46); # .
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(65); # A
  $rc .= chr(78); # N
  $rc .= chr(83); # S
  $rc .= chr(73); # I
  $rc .= chr(46); # .
  $rc .= chr(83); # S
  $rc .= chr(89); # Y
  $rc .= chr(83); # S
  $rc .= chr(32); #  
  $rc .= chr(119); # w
  $rc .= chr(105); # i
  $rc .= chr(116); # t
  $rc .= chr(104); # h
  $rc .= chr(32); #  
  $rc .= chr(107); # k
  $rc .= chr(101); # e
  $rc .= chr(121); # y
  $rc .= chr(112); # p
  $rc .= chr(97); # a
  $rc .= chr(100); # d
  $rc .= chr(32); #  
  $rc .= chr(114); # r
  $rc .= chr(101); # e
  $rc .= chr(100); # d
  $rc .= chr(101); # e
  $rc .= chr(102); # f
  $rc .= chr(105); # i
  $rc .= chr(110); # n
  $rc .= chr(101); # e
  $rc .= chr(100); # d
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(111); # o
  $rc .= chr(114); # r
  $rc .= chr(32); #  
  $rc .= chr(118); # v
  $rc .= chr(105); # i
  $rc .= chr(32); #  
  $rc .= chr(57); # 9
  $rc .= chr(45); # -
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(45); # -
  $rc .= chr(56); # 8
  $rc .= chr(54); # 6
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E+$<20>' => '
#
# Stub version of: \\E+$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          'GOTO' => '
#
# Stub version of: GOTO
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(71); # G
  $rc .= chr(79); # O
  $rc .= chr(84); # T
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\EFP' => '
#
# Stub version of: \\EFP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[%p1%dC' => '
#
# Stub version of: \\E[%p1%dC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C

  return $rc;
}
',
          '^^a' => '
#
# Stub version of: ^^a
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\EH\\002\\EcB1' => '
#
# Stub version of: \\EH\\002\\EcB1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(2); # \\002
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(66); # B
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[g' => '
#
# Stub version of: \\E[g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\E4@\\E<@' => '
#
# Stub version of: \\E4@\\E<@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\Eb\\E[m\\017\\E[?7h' => '
#
# Stub version of: \\Eb\\E[m\\017\\E[?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\037!\\E\\:\\0' => '
#
# Stub version of: \\037!\\E\\:\\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\:
  $rc .= chr(128); # \\0

  return $rc;
}
',
          '\\E[0%?%p1%p5%|%p6%|%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%p6%|%t;7%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p1%p5%|%p6%|%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%p6%|%t;7%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[0]); # %p1
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\E=%i%p2%{31}%+%c%p1%{31}%+%c' => '
#
# Stub version of: \\E=%i%p2%{31}%+%c%p1%{31}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[1]); # %p2
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\030\\E%!0\\EKC\\E\\014\\EKR0\\EKF0\\ENM0\\ELBH=\\ETF8000010F40\\ELI100\\ELLB0\\ELM0\\EKE0\\ENF1\\EKS0\\END0\\ERE0\\E%!1\\Ec\\E[?3;5l\\E[?7;8h\\E[r\\E[m\\E>' => '
#
# Stub version of: \\030\\E%!0\\EKC\\E\\014\\EKR0\\EKF0\\ENM0\\ELBH=\\ETF8000010F40\\ELI100\\ELLB0\\ELM0\\EKE0\\ENF1\\EKS0\\END0\\ERE0\\E%!1\\Ec\\E[?3;5l\\E[?7;8h\\E[r\\E[m\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(24); # \\030
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(12); # \\014
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(82); # R
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(77); # M
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(72); # H
  $rc .= chr(61); # =
  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(70); # F
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(73); # I
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(77); # M
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(69); # E
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(83); # S
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(68); # D
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(69); # E
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '^\\002\\r' => '
#
# Stub version of: ^\\002\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(2); # \\002
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[014z' => '
#
# Stub version of: \\E[014z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\036Fz0' => '
#
# Stub version of: \\036Fz0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(122); # z
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\Eh' => '
#
# Stub version of: \\Eh
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[>1;4B' => '
#
# Stub version of: \\E[>1;4B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E010' => '
#
# Stub version of: \\E010
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\037lef %p1%d\\r' => '
#
# Stub version of: \\037lef %p1%d\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(102); # f
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;12%;m' => '
#
# Stub version of: \\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;12%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(50); # 2
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\r\\n$<1>' => '
#
# Stub version of: \\r\\n$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EF5' => '
#
# Stub version of: \\EF5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\036RG01\\:00??00000000\\036RG01;00000000??00\\036RG01<007?00000000\\036RG01=000000007?00' => '
#
# Stub version of: \\036RG01\\:00??00000000\\036RG01;00000000??00\\036RG01<007?00000000\\036RG01=000000007?00
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\:
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(63); # ?
  $rc .= chr(63); # ?
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(63); # ?
  $rc .= chr(63); # ?
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(60); # <
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(63); # ?
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(61); # =
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(63); # ?
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E$\\177' => '
#
# Stub version of: \\E$\\177
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(127); # \\177

  return $rc;
}
',
          '\\E7\\E[60;0;0;22p\\E8' => '
#
# Stub version of: \\E7\\E[60;0;0;22p\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '^^PE' => '
#
# Stub version of: ^^PE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\EO1;2Q' => '
#
# Stub version of: \\EO1;2Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E[44;1p\\E[255;1H\\E[K' => '
#
# Stub version of: \\E[44;1p\\E[255;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\EA$<3>' => '
#
# Stub version of: \\EA$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ED$<20*>' => '
#
# Stub version of: \\ED$<20*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?1l\\E[?4l\\E[?7h' => '
#
# Stub version of: \\E[?1l\\E[?4l\\E[?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[1;3F' => '
#
# Stub version of: \\E[1;3F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\EOm' => '
#
# Stub version of: \\EOm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(109); # m

  return $rc;
}
',
          '^M^W' => '
#
# Stub version of: ^M^W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^M
  $rc .= chr(0); # ^W

  return $rc;
}
',
          '\\n$<5>' => '
#
# Stub version of: \\n$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\0W' => '
#
# Stub version of: \\0W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\El\\E"' => '
#
# Stub version of: \\El\\E"
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "

  return $rc;
}
',
          '\\E[0;3;4v' => '
#
# Stub version of: \\E[0;3;4v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(118); # v

  return $rc;
}
',
          '^^PI' => '
#
# Stub version of: ^^PI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P
  $rc .= chr(73); # I

  return $rc;
}
',
          '^P^P' => '
#
# Stub version of: ^P^P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(0); # ^P

  return $rc;
}
',
          '\\E[001z' => '
#
# Stub version of: \\E[001z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E&a%p1%dY' => '
#
# Stub version of: \\E&a%p1%dY
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(89); # Y

  return $rc;
}
',
          '\\E[%i%p1%d%%}' => '
#
# Stub version of: \\E[%i%p1%d%%}
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= \'%\';
  $rc .= chr(125); # }

  return $rc;
}
',
          '^Ak\\r' => '
#
# Stub version of: ^Ak\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(107); # k
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^_0' => '
#
# Stub version of: ^_0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^_
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E^H' => '
#
# Stub version of: \\E^H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^H

  return $rc;
}
',
          '\\E*dQ' => '
#
# Stub version of: \\E*dQ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(100); # d
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\ET$<4>' => '
#
# Stub version of: \\ET$<4>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E7\\E[1;24r\\E8' => '
#
# Stub version of: \\E7\\E[1;24r\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[2;7~' => '
#
# Stub version of: \\E[2;7~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[12;0j' => '
#
# Stub version of: \\E[12;0j
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(106); # j

  return $rc;
}
',
          '\\E&ds' => '
#
# Stub version of: \\E&ds
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E[2;4;20;30l\\E[?1;4;10;16l\\E[12h\\E[?7;8;25;67h' => '
#
# Stub version of: \\E[2;4;20;30l\\E[?1;4;10;16l\\E[12h\\E[?7;8;25;67h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '%?%p1%{19}%=%t\\E\\023\\021%e%p1%{32}%<%t\\E%p1%c%e%p1%{127}%=%t\\E\\177%e%p1%c%;' => '
#
# Stub version of: %?%p1%{19}%=%t\\E\\023\\021%e%p1%{32}%<%t\\E%p1%c%e%p1%{127}%=%t\\E\\177%e%p1%c%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 19); # %{19}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(19); # \\023
    $rc .= chr(17); # \\021
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 32); # %{32}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 127); # %{127}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(127); # \\177
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  } # %;

  return $rc;
}
',
          '\\0I' => '
#
# Stub version of: \\0I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(73); # I

  return $rc;
}
',
          'j%k4l<m-q\\,x5' => '
#
# Stub version of: j%k4l<m-q\\,x5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(106); # j
  $rc .= chr(37); # %
  $rc .= chr(107); # k
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(60); # <
  $rc .= chr(109); # m
  $rc .= chr(45); # -
  $rc .= chr(113); # q
  $rc .= chr(128); # \\,
  $rc .= chr(120); # x
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E[>1;5D' => '
#
# Stub version of: \\E[>1;5D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\377\\215' => '
#
# Stub version of: \\377\\215
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(141); # \\215

  return $rc;
}
',
          '\\E[30;47m' => '
#
# Stub version of: \\E[30;47m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '^^2' => '
#
# Stub version of: ^^2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E$$<200/>\\E$P' => '
#
# Stub version of: \\E$$<200/>\\E$P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E7\\E[60;0;0;28p\\E8' => '
#
# Stub version of: \\E7\\E[60;0;0;28p\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[%p1%{30}%+%dm' => '
#
# Stub version of: \\E[%p1%{30}%+%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  push(@iparam, 30); # %{30}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E<\\E>\\E[?1l\\E[?3l\\E[?4l\\E[?5h\\E[?7h\\E[?8h\\E[3g\\E[>5g\\E(B\\E[m\\E[20l\\E[1;24r\\E[24;1H' => '
#
# Stub version of: \\E<\\E>\\E[?1l\\E[?3l\\E[?4l\\E[?5h\\E[?7h\\E[?8h\\E[3g\\E[>5g\\E(B\\E[m\\E[20l\\E[1;24r\\E[24;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '^^(' => '
#
# Stub version of: ^^(
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(40); # (

  return $rc;
}
',
          '\\E&a%p1%dy%p2%dC$<10>' => '
#
# Stub version of: \\E&a%p1%dy%p2%dC$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(121); # y
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0%?%p1%p3%|%t;7%;%?%p2%t;4%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;m' => '
#
# Stub version of: \\E[0%?%p1%p3%|%t;7%;%?%p2%t;4%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[30;40m' => '
#
# Stub version of: \\E[30;40m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E+$<30>' => '
#
# Stub version of: \\E+$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\2334m' => '
#
# Stub version of: \\2334m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '-\\030.^Y0\\333`\\004a\\260f\\370g\\361h\\261i\\025j\\331k\\277l\\332m\\300n\\305q\\304t\\303u\\264v\\301w\\302x\\263y\\363z\\362~\\371' => '
#
# Stub version of: -\\030.^Y0\\333`\\004a\\260f\\370g\\361h\\261i\\025j\\331k\\277l\\332m\\300n\\305q\\304t\\303u\\264v\\301w\\302x\\263y\\363z\\362~\\371
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(45); # -
  $rc .= chr(24); # \\030
  $rc .= chr(46); # .
  $rc .= chr(0); # ^Y
  $rc .= chr(48); # 0
  $rc .= chr(219); # \\333
  $rc .= chr(96); # `
  $rc .= chr(4); # \\004
  $rc .= chr(97); # a
  $rc .= chr(176); # \\260
  $rc .= chr(102); # f
  $rc .= chr(248); # \\370
  $rc .= chr(103); # g
  $rc .= chr(241); # \\361
  $rc .= chr(104); # h
  $rc .= chr(177); # \\261
  $rc .= chr(105); # i
  $rc .= chr(21); # \\025
  $rc .= chr(106); # j
  $rc .= chr(217); # \\331
  $rc .= chr(107); # k
  $rc .= chr(191); # \\277
  $rc .= chr(108); # l
  $rc .= chr(218); # \\332
  $rc .= chr(109); # m
  $rc .= chr(192); # \\300
  $rc .= chr(110); # n
  $rc .= chr(197); # \\305
  $rc .= chr(113); # q
  $rc .= chr(196); # \\304
  $rc .= chr(116); # t
  $rc .= chr(195); # \\303
  $rc .= chr(117); # u
  $rc .= chr(180); # \\264
  $rc .= chr(118); # v
  $rc .= chr(193); # \\301
  $rc .= chr(119); # w
  $rc .= chr(194); # \\302
  $rc .= chr(120); # x
  $rc .= chr(179); # \\263
  $rc .= chr(121); # y
  $rc .= chr(243); # \\363
  $rc .= chr(122); # z
  $rc .= chr(242); # \\362
  $rc .= chr(126); # ~
  $rc .= chr(249); # \\371

  return $rc;
}
',
          '\\E(\\EH\\003' => '
#
# Stub version of: \\E(\\EH\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '^Y\\E' => '
#
# Stub version of: ^Y\\E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Y
  $rc .= chr(27); # \\E

  return $rc;
}
',
          '\\E[4%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m' => '
#
# Stub version of: \\E[4%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  push(@iparam, $param[0]); # %p1
  push(@iparam, 2); # %{2}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 4); # %{4}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  if (do { # %?
           push(@iparam, $staticp->[3]); # %gD
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[20]); # %gU
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[1]); # %gB
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[17]); # %gR
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[1;2S' => '
#
# Stub version of: \\E[1;2S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E[143q' => '
#
# Stub version of: \\E[143q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(51); # 3
  $rc .= chr(113); # q

  return $rc;
}
',
          'F5' => '
#
# Stub version of: F5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E[44p' => '
#
# Stub version of: \\E[44p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[H\\E[J\\E[m\\Ec' => '
#
# Stub version of: \\E[H\\E[J\\E[m\\Ec
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\EF8' => '
#
# Stub version of: \\EF8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[0;4m' => '
#
# Stub version of: \\E[0;4m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Ek$<200>\\EK' => '
#
# Stub version of: \\Ek$<200>\\EK
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E[1;6F' => '
#
# Stub version of: \\E[1;6F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E[H\\E[2J\\EPpS(E)\\E\\\\$<50>' => '
#
# Stub version of: \\E[H\\E[2J\\EPpS(E)\\E\\\\$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(112); # p
  $rc .= chr(83); # S
  $rc .= chr(40); # (
  $rc .= chr(69); # E
  $rc .= chr(41); # )
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\232' => '
#
# Stub version of: \\377\\232
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(154); # \\232

  return $rc;
}
',
          '\\E"N' => '
#
# Stub version of: \\E"N
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(78); # N

  return $rc;
}
',
          '\\EO1' => '
#
# Stub version of: \\EO1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\Es5' => '
#
# Stub version of: \\Es5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E!h\\r' => '
#
# Stub version of: \\E!h\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(104); # h
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E~!\\E~4$<30>' => '
#
# Stub version of: \\E~!\\E~4$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(52); # 4
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[4~' => '
#
# Stub version of: \\E[4~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[u' => '
#
# Stub version of: \\E[u
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\034\\022\\036\\023\\036\\004\\035\\027\\011\\023\\036\\035\\036\\017\\035\\027\\022\\011' => '
#
# Stub version of: \\034\\022\\036\\023\\036\\004\\035\\027\\011\\023\\036\\035\\036\\017\\035\\027\\022\\011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(28); # \\034
  $rc .= chr(18); # \\022
  $rc .= chr(30); # \\036
  $rc .= chr(19); # \\023
  $rc .= chr(30); # \\036
  $rc .= chr(4); # \\004
  $rc .= chr(29); # \\035
  $rc .= chr(23); # \\027
  $rc .= chr(9); # \\011
  $rc .= chr(19); # \\023
  $rc .= chr(30); # \\036
  $rc .= chr(29); # \\035
  $rc .= chr(30); # \\036
  $rc .= chr(15); # \\017
  $rc .= chr(29); # \\035
  $rc .= chr(23); # \\027
  $rc .= chr(18); # \\022
  $rc .= chr(9); # \\011

  return $rc;
}
',
          '\\E[5m$<2/>' => '
#
# Stub version of: \\E[5m$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E=%p1%\' \'%+%c%p2%\' \'%+%c' => '
#
# Stub version of: \\E=%p1%\' \'%+%c%p2%\' \'%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  push(@iparam, chr(32)); # %\' \'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, chr(32)); # %\' \'
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\ESTART\\r\\E60\\,1\\r\\EEND\\r' => '
#
# Stub version of: \\ESTART\\r\\E60\\,1\\r\\EEND\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(84); # T
  $rc .= chr(65); # A
  $rc .= chr(82); # R
  $rc .= chr(84); # T
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(49); # 1
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(78); # N
  $rc .= chr(68); # D
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EY$<100>' => '
#
# Stub version of: \\EY$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&p4u0C' => '
#
# Stub version of: \\E&p4u0C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(112); # p
  $rc .= chr(52); # 4
  $rc .= chr(117); # u
  $rc .= chr(48); # 0
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E*$<80>' => '
#
# Stub version of: \\E*$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\017$<90>' => '
#
# Stub version of: \\017$<90>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(57); # 9
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&v5S' => '
#
# Stub version of: \\E&v5S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(53); # 5
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\EOJ' => '
#
# Stub version of: \\EOJ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\020\\n\\030\\035\\030\\035$<15>' => '
#
# Stub version of: \\020\\n\\030\\035\\030\\035$<15>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  $rc .= chr(10); # \\n
  $rc .= chr(24); # \\030
  $rc .= chr(29); # \\035
  $rc .= chr(24); # \\030
  $rc .= chr(29); # \\035
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0W' => '
#
# Stub version of: \\E[0W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dH$<1>' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dH$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\177' => '
#
# Stub version of: \\177
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(127); # \\177

  return $rc;
}
',
          '\\E005' => '
#
# Stub version of: \\E005
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E\\:^A' => '
#
# Stub version of: \\E\\:^A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\:
  $rc .= chr(0); # ^A

  return $rc;
}
',
          '\\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;m%?%p9%t\\E(0%e\\E(B%;' => '
#
# Stub version of: \\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;m%?%p9%t\\E(0%e\\E(B%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;

  return $rc;
}
',
          '\\E`\\:\\Ee(\\EO\\Ee6\\Ec41\\E~4\\Ec21\\Eu\\E~2' => '
#
# Stub version of: \\E`\\:\\Ee(\\EO\\Ee6\\Ec41\\E~4\\Ec21\\Eu\\E~2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\EFT' => '
#
# Stub version of: \\EFT
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\E[7;2~' => '
#
# Stub version of: \\E[7;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^B\'\\r' => '
#
# Stub version of: ^B\'\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(39); # \'
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^F^J' => '
#
# Stub version of: ^F^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^F
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '\\011$<15>' => '
#
# Stub version of: \\011$<15>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(9); # \\011
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\017%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\017%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[3;5v' => '
#
# Stub version of: \\E[3;5v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\Eg\\r' => '
#
# Stub version of: \\Eg\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E!^F' => '
#
# Stub version of: \\E!^F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(0); # ^F

  return $rc;
}
',
          '\\E[0m$<30>' => '
#
# Stub version of: \\E[0m$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\0@' => '
#
# Stub version of: \\0@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[0%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%e;25%;%?%p6%t;1%;%?%p7%t;8%;m' => '
#
# Stub version of: \\E[0%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%e;25%;%?%p6%t;1%;%?%p7%t;8%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  }
  else { # %e
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EG%p2%c%p1%c' => '
#
# Stub version of: \\EG%p2%c%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\011$<43>' => '
#
# Stub version of: \\011$<43>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(9); # \\011
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E_I\\E\\\\' => '
#
# Stub version of: \\E_I\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\377\\224' => '
#
# Stub version of: \\377\\224
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(148); # \\224

  return $rc;
}
',
          '\\EH\\E]' => '
#
# Stub version of: \\EH\\E]
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]

  return $rc;
}
',
          '\\377\\344' => '
#
# Stub version of: \\377\\344
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(228); # \\344

  return $rc;
}
',
          '400\\E[50;0|' => '
#
# Stub version of: 400\\E[50;0|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\024G1$<200/>\\024T1' => '
#
# Stub version of: \\024G1$<200/>\\024T1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(20); # \\024
  $rc .= chr(71); # G
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(20); # \\024
  $rc .= chr(84); # T
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\ER%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\ER%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[60;1;0;30p\\E[29;1H\\E[K' => '
#
# Stub version of: \\E[60;1;0;30p\\E[29;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\011$<8>' => '
#
# Stub version of: \\011$<8>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(9); # \\011
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(62); # >

  return $rc;
}
',
          '^B9\\r' => '
#
# Stub version of: ^B9\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(57); # 9
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[33p' => '
#
# Stub version of: \\E[33p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[90;1"p\\E[?5W$<6>' => '
#
# Stub version of: \\E[90;1"p\\E[?5W$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E!d\\r' => '
#
# Stub version of: \\E!d\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(100); # d
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EX\\E~\\EZ\\E4\\E(B' => '
#
# Stub version of: \\EX\\E~\\EZ\\E4\\E(B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(27); # \\E
  $rc .= chr(90); # Z
  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[%?%p1%{8}%<%t3%e<%;%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m' => '
#
# Stub version of: \\E[%?%p1%{8}%<%t3%e<%;%p1%{2}%&%?%p1%{1}%&%t%{4}%|%;%?%p1%{4}%&%t%{1}%|%;%d%?%gD%t;2%;%?%gU%t;4%;%?%gB%t;5%;%?%gR%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 8); # %{8}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
  }
  else { # %e
    $rc .= chr(60); # <
  } # %;
  push(@iparam, $param[0]); # %p1
  push(@iparam, 2); # %{2}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 4); # %{4}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  if (do { # %?
           push(@iparam, $staticp->[3]); # %gD
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[20]); # %gU
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[1]); # %gB
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[17]); # %gR
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E7\\E[0;0H\\E[L\\E8' => '
#
# Stub version of: \\E7\\E[0;0H\\E[L\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(76); # L
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\Ec\\E[?1000l\\E[?25h' => '
#
# Stub version of: \\Ec\\E[?1000l\\E[?25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[9;17;25;33;41;49;57;65;73;81;89;97;105;113;121;129u\\r' => '
#
# Stub version of: \\E[9;17;25;33;41;49;57;65;73;81;89;97;105;113;121;129u\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(117); # u
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\0;' => '
#
# Stub version of: \\0;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(59); # ;

  return $rc;
}
',
          '^^|' => '
#
# Stub version of: ^^|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\E%!1\\E[4m$<2>\\E%!0' => '
#
# Stub version of: \\E%!1\\E[4m$<2>\\E%!0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E$A' => '
#
# Stub version of: \\E$A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\377\\373' => '
#
# Stub version of: \\377\\373
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(251); # \\373

  return $rc;
}
',
          '\\E009' => '
#
# Stub version of: \\E009
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9

  return $rc;
}
',
          '6' => '
#
# Stub version of: 6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(54); # 6

  return $rc;
}
',
          '^N' => '
#
# Stub version of: ^N
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^N

  return $rc;
}
',
          '\\EF09' => '
#
# Stub version of: \\EF09
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9

  return $rc;
}
',
          '^AA\\r' => '
#
# Stub version of: ^AA\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(65); # A
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[19;0|\\E[21;1|\\212' => '
#
# Stub version of: \\E[19;0|\\E[21;1|\\212
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |
  $rc .= chr(138); # \\212

  return $rc;
}
',
          '\\233212z' => '
#
# Stub version of: \\233212z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E\\017\\E9' => '
#
# Stub version of: \\E\\017\\E9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\E`' => '
#
# Stub version of: \\E`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `

  return $rc;
}
',
          '\\E[24~' => '
#
# Stub version of: \\E[24~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E&a0y0C' => '
#
# Stub version of: \\E&a0y0C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  $rc .= chr(48); # 0
  $rc .= chr(121); # y
  $rc .= chr(48); # 0
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[%p1%dE$<5>' => '
#
# Stub version of: \\E[%p1%dE$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EF%p2%3d%p1%3d' => '
#
# Stub version of: \\EF%p2%3d%p1%3d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%3d\', pop(@iparam)); # %3d
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%3d\', pop(@iparam)); # %3d

  return $rc;
}
',
          '\\E#C' => '
#
# Stub version of: \\E#C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\EH$<1>\\EJ$<3>' => '
#
# Stub version of: \\EH$<1>\\EJ$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '^\\022\\r' => '
#
# Stub version of: ^\\022\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(18); # \\022
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Ew0$<100>' => '
#
# Stub version of: \\Ew0$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E<\\E[1;24r\\E[24;1H\\E[?7h\\E[>1;2;3;4;5;6;7;8;9l\\E[m\\E[11m' => '
#
# Stub version of: \\E<\\E[1;24r\\E[24;1H\\E[?7h\\E[>1;2;3;4;5;6;7;8;9l\\E[m\\E[11m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\ENG' => '
#
# Stub version of: \\ENG
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(71); # G

  return $rc;
}
',
          '^V#\\s' => '
#
# Stub version of: ^V#\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(35); # #
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E#H' => '
#
# Stub version of: \\E#H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\233H' => '
#
# Stub version of: \\233H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(72); # H

  return $rc;
}
',
          '^^r' => '
#
# Stub version of: ^^r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[m\\E(B$<2>' => '
#
# Stub version of: \\E[m\\E(B$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[3@' => '
#
# Stub version of: \\E[3@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\034W$<5>' => '
#
# Stub version of: \\034W$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(28); # \\034
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[m\\E[K' => '
#
# Stub version of: \\E[m\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\ED$<20/>' => '
#
# Stub version of: \\ED$<20/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[220z' => '
#
# Stub version of: \\E[220z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[7m$<30>' => '
#
# Stub version of: \\E[7m$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EH\\EJ$<120>' => '
#
# Stub version of: \\EH\\EJ$<120>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[70;1H' => '
#
# Stub version of: \\E[70;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '^B\\,\\r' => '
#
# Stub version of: ^B\\,\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(128); # \\,
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[=14;12C' => '
#
# Stub version of: \\E[=14;12C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[310z' => '
#
# Stub version of: \\E[310z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\013%p1%{64}%+%c\\E\\005%p2%02d' => '
#
# Stub version of: \\013%p1%{64}%+%c\\E\\005%p2%02d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  push(@iparam, $param[0]); # %p1
  push(@iparam, 64); # %{64}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(27); # \\E
  $rc .= chr(5); # \\005
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%02d\', pop(@iparam)); # %02d

  return $rc;
}
',
          'Num -' => '
#
# Stub version of: Num -
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(78); # N
  $rc .= chr(117); # u
  $rc .= chr(109); # m
  $rc .= chr(32); #  
  $rc .= chr(45); # -

  return $rc;
}
',
          '\\E.3\\Er\\E[1;25r\\E[25;0H' => '
#
# Stub version of: \\E.3\\Er\\E[1;25r\\E[25;0H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\EY$<80>' => '
#
# Stub version of: \\EY$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%p1%dX$<20>' => '
#
# Stub version of: \\E[%p1%dX$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(88); # X
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ENd' => '
#
# Stub version of: \\ENd
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\23345~' => '
#
# Stub version of: \\23345~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(52); # 4
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EO2C' => '
#
# Stub version of: \\EO2C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(50); # 2
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\EO6B' => '
#
# Stub version of: \\EO6B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(54); # 6
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[M' => '
#
# Stub version of: \\E[M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\E[40l\\E[40h\\E7\\E[99;%i%p1%dH' => '
#
# Stub version of: \\E[40l\\E[40h\\E7\\E[99;%i%p1%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\EAUF' => '
#
# Stub version of: \\EAUF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(85); # U
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E#$<2.1*/>' => '
#
# Stub version of: \\E#$<2.1*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(46); # .
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[34l\\E[?25h' => '
#
# Stub version of: \\E[34l\\E[?25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[0$~' => '
#
# Stub version of: \\E[0$~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(126); # ~

  return $rc;
}
',
          '~\\032$<40>' => '
#
# Stub version of: ~\\032$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(26); # \\032
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\356' => '
#
# Stub version of: \\377\\356
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(238); # \\356

  return $rc;
}
',
          '\\EO3Q' => '
#
# Stub version of: \\EO3Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(51); # 3
  $rc .= chr(81); # Q

  return $rc;
}
',
          '^Ag\\r' => '
#
# Stub version of: ^Ag\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(103); # g
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\020\\034\\030\\035$<10*>' => '
#
# Stub version of: \\020\\034\\030\\035$<10*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  $rc .= chr(28); # \\034
  $rc .= chr(24); # \\030
  $rc .= chr(29); # \\035
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[U 7\\E[24;1H' => '
#
# Stub version of: \\E[U 7\\E[24;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(85); # U
  $rc .= chr(32); #  
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[>1;3D' => '
#
# Stub version of: \\E[>1;3D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\035dow %p1%d;' => '
#
# Stub version of: \\035dow %p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(100); # d
  $rc .= chr(111); # o
  $rc .= chr(119); # w
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[%p1%dd$<40>' => '
#
# Stub version of: \\E[%p1%dd$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(100); # d
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^B!\\r' => '
#
# Stub version of: ^B!\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(33); # !
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\0d' => '
#
# Stub version of: \\0d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\E[[A' => '
#
# Stub version of: \\E[[A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\024%p1%{24}%+%c%p2%p2%?%{47}%>%t%{48}%+%;%{80}%+%c' => '
#
# Stub version of: \\024%p1%{24}%+%c%p2%p2%?%{47}%>%t%{48}%+%;%{80}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(20); # \\024
  push(@iparam, $param[0]); # %p1
  push(@iparam, 24); # %{24}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, $param[1]); # %p2
  if (do { # %?
           push(@iparam, 47); # %{47}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    push(@iparam, 48); # %{48}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  push(@iparam, 80); # %{80}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\233C' => '
#
# Stub version of: \\233C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(67); # C

  return $rc;
}
',
          '^^FI' => '
#
# Stub version of: ^^FI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(70); # F
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\377\\326' => '
#
# Stub version of: \\377\\326
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(214); # \\326

  return $rc;
}
',
          '\\EO1;5A' => '
#
# Stub version of: \\EO1;5A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\EKA1\\ELV1' => '
#
# Stub version of: \\EKA1\\ELV1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(65); # A
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(86); # V
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[\\^' => '
#
# Stub version of: \\E[\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\E!^G' => '
#
# Stub version of: \\E!^G
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(0); # ^G

  return $rc;
}
',
          '\\014$<1>\\013@' => '
#
# Stub version of: \\014$<1>\\013@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >
  $rc .= chr(11); # \\013
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[?3l\\E)0' => '
#
# Stub version of: \\E[?3l\\E)0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dr' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dr
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\031\\Es1' => '
#
# Stub version of: \\031\\Es1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(25); # \\031
  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E%?%p1%p5%|%t)%e(%; \\010\\E%?%p1%p3%|%tj%ek%;\\010\\E%?%p2%tl%em%;\\010\\E%?%p7%t_%e%?%p4%t\\^%eq%;%;' => '
#
# Stub version of: \\E%?%p1%p5%|%t)%e(%; \\010\\E%?%p1%p3%|%tj%ek%;\\010\\E%?%p2%tl%em%;\\010\\E%?%p7%t_%e%?%p4%t\\^%eq%;%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(41); # )
  }
  else { # %e
    $rc .= chr(40); # (
  } # %;
  $rc .= chr(32); #  
  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(106); # j
  }
  else { # %e
    $rc .= chr(107); # k
  } # %;
  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(108); # l
  }
  else { # %e
    $rc .= chr(109); # m
  } # %;
  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(95); # _
  }
  else { # %e
    if (do { # %?
             push(@iparam, $param[3]); # %p4
             pop(@iparam);
           }) { # %t
      $rc .= chr(128); # \\^
    }
    else { # %e
      $rc .= chr(113); # q
    } # %;
  } # %;

  return $rc;
}
',
          '\\377\\267' => '
#
# Stub version of: \\377\\267
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(183); # \\267

  return $rc;
}
',
          '^^F`' => '
#
# Stub version of: ^^F`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(70); # F
  $rc .= chr(96); # `

  return $rc;
}
',
          '\\E[V' => '
#
# Stub version of: \\E[V
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(86); # V

  return $rc;
}
',
          '\\E#7' => '
#
# Stub version of: \\E#7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\E[19;1|' => '
#
# Stub version of: \\E[19;1|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\Ed$<3>' => '
#
# Stub version of: \\Ed$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[3D' => '
#
# Stub version of: \\E[3D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\021$<350>' => '
#
# Stub version of: \\021$<350>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(17); # \\021
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^B"\\r' => '
#
# Stub version of: ^B"\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(34); # "
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\377\\244' => '
#
# Stub version of: \\377\\244
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(164); # \\244

  return $rc;
}
',
          '\\EE' => '
#
# Stub version of: \\EE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\E[4B' => '
#
# Stub version of: \\E[4B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\EyQ' => '
#
# Stub version of: \\EyQ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E[61"p\\E[H\\E[?3l\\E[?4l\\E[?1h\\E[?5l\\E[?6l\\E[?7h\\E[?8h\\E[?25h\\E>\\E[m' => '
#
# Stub version of: \\E[61"p\\E[H\\E[?3l\\E[?4l\\E[?1h\\E[?5l\\E[?6l\\E[?7h\\E[?8h\\E[?25h\\E>\\E[m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(49); # 1
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[B$<2>' => '
#
# Stub version of: \\E[B$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(66); # B
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1;5Q' => '
#
# Stub version of: \\E[1;5Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E[0%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;11%;m' => '
#
# Stub version of: \\E[0%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;11%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E~)\\E~ea' => '
#
# Stub version of: \\E~)\\E~ea
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(41); # )
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(101); # e
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\E[>+1$<70>' => '
#
# Stub version of: \\E[>+1$<70>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(43); # +
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[247z' => '
#
# Stub version of: \\E[247z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E%!0\\E%\\014\\ELV0\\EKA1\\ELBB2\\ENU@=\\ELLB2\\ELM0\\ELV1\\EKYA?\\E%!1\\E[<1l\\E[?7h\\E[?8h\\E[34;1H\\E[34B\\E[m' => '
#
# Stub version of: \\E%!0\\E%\\014\\ELV0\\EKA1\\ELBB2\\ENU@=\\ELLB2\\ELM0\\ELV1\\EKYA?\\E%!1\\E[<1l\\E[?7h\\E[?8h\\E[34;1H\\E[34B\\E[m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(12); # \\014
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(86); # V
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(65); # A
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(66); # B
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(85); # U
  $rc .= chr(64); # @
  $rc .= chr(61); # =
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(77); # M
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(86); # V
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(89); # Y
  $rc .= chr(65); # A
  $rc .= chr(63); # ?
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m

  return $rc;
}
',
          '$<9>\\r' => '
#
# Stub version of: $<9>\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(57); # 9
  $rc .= chr(62); # >
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E>\\E[?1l' => '
#
# Stub version of: \\E>\\E[?1l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E\\023%p1%c%p2%c' => '
#
# Stub version of: \\E\\023%p1%c%p2%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\EO1;6Q' => '
#
# Stub version of: \\EO1;6Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\EO7A' => '
#
# Stub version of: \\EO7A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(55); # 7
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\EM$<5*/>' => '
#
# Stub version of: \\EM$<5*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\260' => '
#
# Stub version of: \\377\\260
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(176); # \\260

  return $rc;
}
',
          '^P^T' => '
#
# Stub version of: ^P^T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(0); # ^T

  return $rc;
}
',
          '\\036$<25>' => '
#
# Stub version of: \\036$<25>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E7\\E[60;0;0;30p\\E8' => '
#
# Stub version of: \\E7\\E[60;0;0;30p\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[OP' => '
#
# Stub version of: \\E[OP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(79); # O
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[0K$<5>' => '
#
# Stub version of: \\E[0K$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%p1%d;%p2%l%02dq   f%p1%d           %p2%s' => '
#
# Stub version of: \\E[%p1%d;%p2%l%02dq   f%p1%d           %p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%02d\', pop(@iparam)); # %02d
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\E[L$<2*>' => '
#
# Stub version of: \\E[L$<2*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[6;7~' => '
#
# Stub version of: \\E[6;7~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[7!{' => '
#
# Stub version of: \\E[7!{
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(33); # !
  $rc .= chr(123); # {

  return $rc;
}
',
          '\\EFw' => '
#
# Stub version of: \\EFw
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\E[23;2~' => '
#
# Stub version of: \\E[23;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\035sto;' => '
#
# Stub version of: \\035sto;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(111); # o
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\233?7l' => '
#
# Stub version of: \\233?7l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[0;37;40m\\E[H\\E[J' => '
#
# Stub version of: \\E[0;37;40m\\E[H\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\EJ$<5.5*>' => '
#
# Stub version of: \\EJ$<5.5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[30h\\E\\,\\E[30l$<250>' => '
#
# Stub version of: \\E[30h\\E\\,\\E[30l$<250>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\,
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[7B' => '
#
# Stub version of: \\E[7B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[L$<3/>' => '
#
# Stub version of: \\E[L$<3/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E%!0\\ELBP0\\E%!1\\E[H\\E[2g\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[J' => '
#
# Stub version of: \\E%!0\\ELBP0\\E%!1\\E[H\\E[2g\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[8C\\EH\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(80); # P
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[?5l' => '
#
# Stub version of: \\E[?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[0m$<2>' => '
#
# Stub version of: \\E[0m$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '^I' => '
#
# Stub version of: ^I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^I

  return $rc;
}
',
          '\\EP`>y~[[J`8xy~[[A`4xy~[[D`6xy~[[C`2xy~[[B\\E\\\\' => '
#
# Stub version of: \\EP`>y~[[J`8xy~[[A`4xy~[[D`6xy~[[C`2xy~[[B\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(96); # `
  $rc .= chr(62); # >
  $rc .= chr(121); # y
  $rc .= chr(126); # ~
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(96); # `
  $rc .= chr(56); # 8
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(126); # ~
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(96); # `
  $rc .= chr(52); # 4
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(126); # ~
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(68); # D
  $rc .= chr(96); # `
  $rc .= chr(54); # 6
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(126); # ~
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(67); # C
  $rc .= chr(96); # `
  $rc .= chr(50); # 2
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(126); # ~
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E`c' => '
#
# Stub version of: \\E`c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E[27m$<5/>' => '
#
# Stub version of: \\E[27m$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EV"' => '
#
# Stub version of: \\EV"
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(34); # "

  return $rc;
}
',
          '\\E[36;2~' => '
#
# Stub version of: \\E[36;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\0O' => '
#
# Stub version of: \\0O
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\Ee6\\E~"$<100>\\E+\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`;\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<200>' => '
#
# Stub version of: \\Ee6\\E~"$<100>\\E+\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`;\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(34); # "
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(59); # ;
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(55); # 7
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E/>7l' => '
#
# Stub version of: \\E/>7l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(55); # 7
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EO6P' => '
#
# Stub version of: \\EO6P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(54); # 6
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\250' => '
#
# Stub version of: \\250
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(168); # \\250

  return $rc;
}
',
          '\\E[7m\\016' => '
#
# Stub version of: \\E[7m\\016
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(14); # \\016

  return $rc;
}
',
          '~^O' => '
#
# Stub version of: ~^O
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(0); # ^O

  return $rc;
}
',
          '\\376M' => '
#
# Stub version of: \\376M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(254); # \\376
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\E.0' => '
#
# Stub version of: \\E.0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E\'\\E(\\032' => '
#
# Stub version of: \\E\'\\E(\\032
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(26); # \\032

  return $rc;
}
',
          '\\E7\\E[;0p\\E[1;1H\\E[K\\E[H\\E8\\r\\n\\E[K' => '
#
# Stub version of: \\E7\\E[;0p\\E[1;1H\\E[K\\E[H\\E8\\r\\n\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '^Al\\r' => '
#
# Stub version of: ^Al\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(108); # l
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E4P' => '
#
# Stub version of: \\E4P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E&s1A' => '
#
# Stub version of: \\E&s1A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(115); # s
  $rc .= chr(49); # 1
  $rc .= chr(65); # A

  return $rc;
}
',
          '^A' => '
#
# Stub version of: ^A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A

  return $rc;
}
',
          '\\E[21;3~' => '
#
# Stub version of: \\E[21;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\377\\333' => '
#
# Stub version of: \\377\\333
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(219); # \\333

  return $rc;
}
',
          '^M\\Eg' => '
#
# Stub version of: ^M\\Eg
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^M
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\Er\\EO' => '
#
# Stub version of: \\Er\\EO
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\E?\\E[3;3|\\E[10;0|\\E[21;1|\\212\\E[6;1|\\E[1{\\E[?99l' => '
#
# Stub version of: \\E?\\E[3;3|\\E[10;0|\\E[21;1|\\212\\E[6;1|\\E[1{\\E[?99l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |
  $rc .= chr(138); # \\212
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(123); # {
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[2r' => '
#
# Stub version of: \\E[2r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(114); # r

  return $rc;
}
',
          '^^i' => '
#
# Stub version of: ^^i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E[7;4~' => '
#
# Stub version of: \\E[7;4~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[1M$<1*>' => '
#
# Stub version of: \\E[1M$<1*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[153q' => '
#
# Stub version of: \\E[153q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(51); # 3
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\EJ$<6*/>' => '
#
# Stub version of: \\EJ$<6*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '^V^B' => '
#
# Stub version of: ^V^B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^B

  return $rc;
}
',
          '^AF\\r' => '
#
# Stub version of: ^AF\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(70); # F
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^^+' => '
#
# Stub version of: ^^+
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(43); # +

  return $rc;
}
',
          '\\EO5A' => '
#
# Stub version of: \\EO5A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(53); # 5
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[L$<5*/>' => '
#
# Stub version of: \\E[L$<5*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\204' => '
#
# Stub version of: \\377\\204
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(132); # \\204

  return $rc;
}
',
          '\\E[150q' => '
#
# Stub version of: \\E[150q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[05s' => '
#
# Stub version of: \\E[05s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E[210z' => '
#
# Stub version of: \\E[210z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[60;0;0;48p\\E[48;1H\\E[K' => '
#
# Stub version of: \\E[60;0;0;48p\\E[48;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E[5m$<2>' => '
#
# Stub version of: \\E[5m$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E>\\E[1;3;4;5;6l\\E[?7h\\E[100m\\E[m\\E[r\\E[2J\\E[H' => '
#
# Stub version of: \\E>\\E[1;3;4;5;6l\\E[?7h\\E[100m\\E[m\\E[r\\E[2J\\E[H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[?3h\\E[=40h' => '
#
# Stub version of: \\E[?3h\\E[=40h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[?3h\\E)0' => '
#
# Stub version of: \\E[?3h\\E)0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[7;3~' => '
#
# Stub version of: \\E[7;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[0J$<5>' => '
#
# Stub version of: \\E[0J$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?3h\\Eb' => '
#
# Stub version of: \\E[?3h\\Eb
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E[35h\\E[?3h$<80>' => '
#
# Stub version of: \\E[35h\\E[?3h$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^j' => '
#
# Stub version of: ^^j
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(106); # j

  return $rc;
}
',
          '\\E[1C' => '
#
# Stub version of: \\E[1C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[?13h' => '
#
# Stub version of: \\E[?13h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[18 D' => '
#
# Stub version of: \\E[18 D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(32); #  
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\El$<2>' => '
#
# Stub version of: \\El$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ek$<16.1*>' => '
#
# Stub version of: \\Ek$<16.1*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(46); # .
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\'I' => '
#
# Stub version of: \\E\'I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\EOt' => '
#
# Stub version of: \\EOt
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\E[1;4H' => '
#
# Stub version of: \\E[1;4H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\233006z' => '
#
# Stub version of: \\233006z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(122); # z

  return $rc;
}
',
          '^B&\\r' => '
#
# Stub version of: ^B&\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(38); # &
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '30*\\EE' => '
#
# Stub version of: 30*\\EE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\EOE' => '
#
# Stub version of: \\EOE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\EFC' => '
#
# Stub version of: \\EFC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\Ev\\Eq\\Ee\\Eb1\\Ec0' => '
#
# Stub version of: \\Ev\\Eq\\Ee\\Eb1\\Ec0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\Em\\En' => '
#
# Stub version of: \\Em\\En
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\E7\\E[60;0;0;30p\\E[1;1H\\E[K\\E[H\\E8\\r\\n\\E[K' => '
#
# Stub version of: \\E7\\E[60;0;0;30p\\E[1;1H\\E[K\\E[H\\E8\\r\\n\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '^\\049\\r' => '
#
# Stub version of: ^\\049\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(128); # \\0
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EL\\r' => '
#
# Stub version of: \\EL\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '+\\257\\,\\256-\\^0\\333`\\004a\\261f\\370g\\361h\\260j\\331k\\277l\\332m\\300n\\305o~p\\304q\\304r\\304s_t\\303u\\264v\\301w\\302x\\263y\\363z\\362{\\343|\\330~\\376' => '
#
# Stub version of: +\\257\\,\\256-\\^0\\333`\\004a\\261f\\370g\\361h\\260j\\331k\\277l\\332m\\300n\\305o~p\\304q\\304r\\304s_t\\303u\\264v\\301w\\302x\\263y\\363z\\362{\\343|\\330~\\376
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(175); # \\257
  $rc .= chr(128); # \\,
  $rc .= chr(174); # \\256
  $rc .= chr(45); # -
  $rc .= chr(128); # \\^
  $rc .= chr(48); # 0
  $rc .= chr(219); # \\333
  $rc .= chr(96); # `
  $rc .= chr(4); # \\004
  $rc .= chr(97); # a
  $rc .= chr(177); # \\261
  $rc .= chr(102); # f
  $rc .= chr(248); # \\370
  $rc .= chr(103); # g
  $rc .= chr(241); # \\361
  $rc .= chr(104); # h
  $rc .= chr(176); # \\260
  $rc .= chr(106); # j
  $rc .= chr(217); # \\331
  $rc .= chr(107); # k
  $rc .= chr(191); # \\277
  $rc .= chr(108); # l
  $rc .= chr(218); # \\332
  $rc .= chr(109); # m
  $rc .= chr(192); # \\300
  $rc .= chr(110); # n
  $rc .= chr(197); # \\305
  $rc .= chr(111); # o
  $rc .= chr(126); # ~
  $rc .= chr(112); # p
  $rc .= chr(196); # \\304
  $rc .= chr(113); # q
  $rc .= chr(196); # \\304
  $rc .= chr(114); # r
  $rc .= chr(196); # \\304
  $rc .= chr(115); # s
  $rc .= chr(95); # _
  $rc .= chr(116); # t
  $rc .= chr(195); # \\303
  $rc .= chr(117); # u
  $rc .= chr(180); # \\264
  $rc .= chr(118); # v
  $rc .= chr(193); # \\301
  $rc .= chr(119); # w
  $rc .= chr(194); # \\302
  $rc .= chr(120); # x
  $rc .= chr(179); # \\263
  $rc .= chr(121); # y
  $rc .= chr(243); # \\363
  $rc .= chr(122); # z
  $rc .= chr(242); # \\362
  $rc .= chr(123); # {
  $rc .= chr(227); # \\343
  $rc .= chr(124); # |
  $rc .= chr(216); # \\330
  $rc .= chr(126); # ~
  $rc .= chr(254); # \\376

  return $rc;
}
',
          '\\E[7m\\s' => '
#
# Stub version of: \\E[7m\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '^B0^J' => '
#
# Stub version of: ^B0^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(48); # 0
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '\\E[309z' => '
#
# Stub version of: \\E[309z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[50%?%p1%p3%|%p6%|%t;7%{1}%e%{0}%;%PR%?%p4%t;5%{1}%e%{0}%;%PB%?%p2%p6%|%t;4%{1}%e%{0}%;%PU%?%p1%p5%|%t;2%{1}%e%{0}%;%PDm\\E)%?%p9%t6\\016%e4\\017%;' => '
#
# Stub version of: \\E[50%?%p1%p3%|%p6%|%t;7%{1}%e%{0}%;%PR%?%p4%t;5%{1}%e%{0}%;%PB%?%p2%p6%|%t;4%{1}%e%{0}%;%PU%?%p1%p5%|%t;2%{1}%e%{0}%;%PDm\\E)%?%p9%t6\\016%e4\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
    push(@iparam, 1); # %{1}
  }
  else { # %e
    push(@iparam, 0); # %{0}
  } # %;
  $staticp->[17] = pop(@iparam); # %PR
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
    push(@iparam, 1); # %{1}
  }
  else { # %e
    push(@iparam, 0); # %{0}
  } # %;
  $staticp->[1] = pop(@iparam); # %PB
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
    push(@iparam, 1); # %{1}
  }
  else { # %e
    push(@iparam, 0); # %{0}
  } # %;
  $staticp->[20] = pop(@iparam); # %PU
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
    push(@iparam, 1); # %{1}
  }
  else { # %e
    push(@iparam, 0); # %{0}
  } # %;
  $staticp->[3] = pop(@iparam); # %PD
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(52); # 4
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\ESTART\\r\\E60\\,0\\r\\EEND\\r' => '
#
# Stub version of: \\ESTART\\r\\E60\\,0\\r\\EEND\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(84); # T
  $rc .= chr(65); # A
  $rc .= chr(82); # R
  $rc .= chr(84); # T
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(78); # N
  $rc .= chr(68); # D
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[1;33;44m\\E[H\\E[J' => '
#
# Stub version of: \\E[1;33;44m\\E[H\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '^^]' => '
#
# Stub version of: ^^]
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(93); # ]

  return $rc;
}
',
          '\\Ej$<3>' => '
#
# Stub version of: \\Ej$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '%?%p9%t\\E(0%e\\E(B%;\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m' => '
#
# Stub version of: %?%p9%t\\E(0%e\\E(B%;\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E\\s\\s\\s' => '
#
# Stub version of: \\E\\s\\s\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(32); # \\s
  $rc .= chr(32); # \\s
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E=%p2%{32}%+%c%p1%{32}%+%c' => '
#
# Stub version of: \\E=%p2%{32}%+%c%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '^CE' => '
#
# Stub version of: ^CE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^C
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\233113z' => '
#
# Stub version of: \\233113z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[0;10;39m' => '
#
# Stub version of: \\E[0;10;39m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(57); # 9
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[313z' => '
#
# Stub version of: \\E[313z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '^\\021\\r' => '
#
# Stub version of: ^\\021\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(17); # \\021
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%?%p1%t7;%;%?%p2%t4;%;%?%p3%t7;%;%?%p4%t5;%;%?%p5%t2;%;%?%p7%t8;%;m' => '
#
# Stub version of: \\E[%?%p1%t7;%;%?%p2%t4;%;%?%p3%t7;%;%?%p4%t5;%;%?%p5%t2;%;%?%p7%t8;%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(56); # 8
    $rc .= chr(59); # ;
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E&dH' => '
#
# Stub version of: \\E&dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\EN*' => '
#
# Stub version of: \\EN*
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(42); # *

  return $rc;
}
',
          '\\233?5h$<200/>\\233?5l' => '
#
# Stub version of: \\233?5h$<200/>\\233?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[3%p1%dm' => '
#
# Stub version of: \\E[3%p1%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E?' => '
#
# Stub version of: \\E?
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?

  return $rc;
}
',
          '^B5^J' => '
#
# Stub version of: ^B5^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(53); # 5
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '\\E[13l\\E[3l\\E\\\\\\E[63;1"p\\E[!p' => '
#
# Stub version of: \\E[13l\\E[3l\\E\\\\\\E[63;1"p\\E[!p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\EOy' => '
#
# Stub version of: \\EOy
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(121); # y

  return $rc;
}
',
          '\\EM$<2>' => '
#
# Stub version of: \\EM$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[25~' => '
#
# Stub version of: \\E[25~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E0h' => '
#
# Stub version of: \\E0h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E]0;' => '
#
# Stub version of: \\E]0;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[229z' => '
#
# Stub version of: \\E[229z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[%?%p6%t1;%;%?%p2%t4;%;%?%p3%t7;%;%?%p4%t5;%;%?%p1%!%t7;%;%?%p7%t8;%;m' => '
#
# Stub version of: \\E[%?%p6%t1;%;%?%p2%t4;%;%?%p3%t7;%;%?%p4%t5;%;%?%p1%!%t7;%;%?%p7%t8;%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, ! pop(@iparam)); # %!
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(56); # 8
    $rc .= chr(59); # ;
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\013%p1%c' => '
#
# Stub version of: \\013%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E!9/N\\E>B' => '
#
# Stub version of: \\E!9/N\\E>B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(57); # 9
  $rc .= chr(47); # /
  $rc .= chr(78); # N
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\ERA' => '
#
# Stub version of: \\ERA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\Ev  \\002 p\\Ep\\r\\n' => '
#
# Stub version of: \\Ev  \\002 p\\Ep\\r\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(2); # \\002
  $rc .= chr(32); #  
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\E[%p1%dD$<5>' => '
#
# Stub version of: \\E[%p1%dD$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(68); # D
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[3m' => '
#
# Stub version of: \\E[3m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E!\\0' => '
#
# Stub version of: \\E!\\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(128); # \\0

  return $rc;
}
',
          '\\E[@$<4/>' => '
#
# Stub version of: \\E[@$<4/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(64); # @
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\217P' => '
#
# Stub version of: \\217P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E(009\\,017\\,025\\,033\\,041\\,049\\,057\\,065\\,073\\,081\\,089.' => '
#
# Stub version of: \\E(009\\,017\\,025\\,033\\,041\\,049\\,057\\,065\\,073\\,081\\,089.
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(55); # 7
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(57); # 9
  $rc .= chr(46); # .

  return $rc;
}
',
          '\\EO4Q' => '
#
# Stub version of: \\EO4Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(52); # 4
  $rc .= chr(81); # Q

  return $rc;
}
',
          'TAB CLEAR' => '
#
# Stub version of: TAB CLEAR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(84); # T
  $rc .= chr(65); # A
  $rc .= chr(66); # B
  $rc .= chr(32); #  
  $rc .= chr(67); # C
  $rc .= chr(76); # L
  $rc .= chr(69); # E
  $rc .= chr(65); # A
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[2;2~' => '
#
# Stub version of: \\E[2;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[009q' => '
#
# Stub version of: \\E[009q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(113); # q

  return $rc;
}
',
          '^Y^X' => '
#
# Stub version of: ^Y^X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Y
  $rc .= chr(0); # ^X

  return $rc;
}
',
          '\\EN~' => '
#
# Stub version of: \\EN~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dr$<5>' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dr$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(114); # r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[14;5~' => '
#
# Stub version of: \\E[14;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '$<7>' => '
#
# Stub version of: $<7>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E?a' => '
#
# Stub version of: \\E?a
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(97); # a

  return $rc;
}
',
          '^Pb' => '
#
# Stub version of: ^Pb
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\037$<5>' => '
#
# Stub version of: \\037$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '$<16*>' => '
#
# Stub version of: $<16*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[3\\^' => '
#
# Stub version of: \\E[3\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\E[2J\\E[H' => '
#
# Stub version of: \\E[2J\\E[H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\Eb$' => '
#
# Stub version of: \\Eb$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\031$<200/>' => '
#
# Stub version of: \\031$<200/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(25); # \\031
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[4m$<2>' => '
#
# Stub version of: \\E[4m$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E<\\Ec\\0' => '
#
# Stub version of: \\E<\\Ec\\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(128); # \\0

  return $rc;
}
',
          '~^S' => '
#
# Stub version of: ~^S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(0); # ^S

  return $rc;
}
',
          '\\E[30h\\E\\,\\E[30l$<300>' => '
#
# Stub version of: \\E[30h\\E\\,\\E[30l$<300>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\,
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          'A clear' => '
#
# Stub version of: A clear
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(65); # A
  $rc .= chr(32); #  
  $rc .= chr(99); # c
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(97); # a
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[?4h' => '
#
# Stub version of: \\E[?4h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[%p1%{32}%+%c' => '
#
# Stub version of: \\E[%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[213z' => '
#
# Stub version of: \\E[213z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '+h.k0affggolpnqprrss' => '
#
# Stub version of: +h.k0affggolpnqprrss
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(104); # h
  $rc .= chr(46); # .
  $rc .= chr(107); # k
  $rc .= chr(48); # 0
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(111); # o
  $rc .= chr(108); # l
  $rc .= chr(112); # p
  $rc .= chr(110); # n
  $rc .= chr(113); # q
  $rc .= chr(112); # p
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E[1P' => '
#
# Stub version of: \\E[1P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\036N\\036FS0>\\036O\\036FS00' => '
#
# Stub version of: \\036N\\036FS0>\\036O\\036FS00
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(78); # N
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(30); # \\036
  $rc .= chr(79); # O
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[108z' => '
#
# Stub version of: \\E[108z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[5C' => '
#
# Stub version of: \\E[5C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E7\\E[r\\E8\\EE\\EE\\EE\\EM\\EM\\EM\\E[?7h\\E[?1l\\E[?3l\\E7\\E[1;31r\\E8' => '
#
# Stub version of: \\E7\\E[r\\E8\\EE\\EE\\EE\\EM\\EM\\EM\\E[?7h\\E[?1l\\E[?3l\\E7\\E[1;31r\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\017\\E%\\E\'\\E(\\EDF\\EC\\EG0\\EN0\\Es0\\Ev0' => '
#
# Stub version of: \\017\\E%\\E\'\\E(\\EDF\\EC\\EG0\\EN0\\Es0\\Ev0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[m\\E)4\\017' => '
#
# Stub version of: \\E[m\\E)4\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(52); # 4
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\E[p\\E[>?6l' => '
#
# Stub version of: \\E[p\\E[>?6l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[i' => '
#
# Stub version of: \\E[i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(105); # i

  return $rc;
}
',
          '^B9^J' => '
#
# Stub version of: ^B9^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(57); # 9
  $rc .= chr(0); # ^J

  return $rc;
}
',
          '\\E[4ZZ' => '
#
# Stub version of: \\E[4ZZ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(90); # Z
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\013%p1%{32}%+%c\\020%p2%{10}%/%{16}%*%p2%{10}%m%+%Pc%?%{17}%gc%=%{19}%gc%=%|%gc%!%|%t%{1}%gc%+%c%{8}%e%gc%;%c' => '
#
# Stub version of: \\013%p1%{32}%+%c\\020%p2%{10}%/%{16}%*%p2%{10}%m%+%Pc%?%{17}%gc%=%{19}%gc%=%|%gc%!%|%t%{1}%gc%+%c%{8}%e%gc%;%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(16); # \\020
  push(@iparam, $param[1]); # %p2
  push(@iparam, 10); # %{10}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 16); # %{16}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, $param[1]); # %p2
  push(@iparam, 10); # %{10}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $dynamicp->[2] = pop(@iparam); # %Pc
  if (do { # %?
           push(@iparam, 17); # %{17}
           push(@iparam, $dynamicp->[2]); # %gc
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           push(@iparam, 19); # %{19}
           push(@iparam, $dynamicp->[2]); # %gc
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $dynamicp->[2]); # %gc
           push(@iparam, ! pop(@iparam)); # %!
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, $dynamicp->[2]); # %gc
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
    push(@iparam, 8); # %{8}
  }
  else { # %e
    push(@iparam, $dynamicp->[2]); # %gc
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[H\\E[2J\\E[1U\\E[H\\E[2J\\E[1V' => '
#
# Stub version of: \\E[H\\E[2J\\E[1U\\E[H\\E[2J\\E[1V
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(86); # V

  return $rc;
}
',
          '\\233i' => '
#
# Stub version of: \\233i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\ER%p2%03d%p1%c' => '
#
# Stub version of: \\ER%p2%03d%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%03d\', pop(@iparam)); # %03d
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '``aaffggj)k\\,l&m#n/ooppq*rrsst\'u-v+w.x%yyzz{{||}}~~' => '
#
# Stub version of: ``aaffggj)k\\,l&m#n/ooppq*rrsst\'u-v+w.x%yyzz{{||}}~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(106); # j
  $rc .= chr(41); # )
  $rc .= chr(107); # k
  $rc .= chr(128); # \\,
  $rc .= chr(108); # l
  $rc .= chr(38); # &
  $rc .= chr(109); # m
  $rc .= chr(35); # #
  $rc .= chr(110); # n
  $rc .= chr(47); # /
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(42); # *
  $rc .= chr(114); # r
  $rc .= chr(114); # r
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(39); # \'
  $rc .= chr(117); # u
  $rc .= chr(45); # -
  $rc .= chr(118); # v
  $rc .= chr(43); # +
  $rc .= chr(119); # w
  $rc .= chr(46); # .
  $rc .= chr(120); # x
  $rc .= chr(37); # %
  $rc .= chr(121); # y
  $rc .= chr(121); # y
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(123); # {
  $rc .= chr(123); # {
  $rc .= chr(124); # |
  $rc .= chr(124); # |
  $rc .= chr(125); # }
  $rc .= chr(125); # }
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[>l' => '
#
# Stub version of: \\E[>l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[T\\E[A' => '
#
# Stub version of: \\E[T\\E[A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(84); # T
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\031%p1%c%p2%c' => '
#
# Stub version of: \\031%p1%c%p2%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(25); # \\031
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\EL$<50>' => '
#
# Stub version of: \\EL$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[218q' => '
#
# Stub version of: \\E[218q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[=0;<1m' => '
#
# Stub version of: \\E[=0;<1m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Ee\\r' => '
#
# Stub version of: \\Ee\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EM$<50>' => '
#
# Stub version of: \\EM$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^A7\\r' => '
#
# Stub version of: ^A7\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(55); # 7
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^\\018\\r' => '
#
# Stub version of: ^\\018\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(128); # \\0
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\ER\\EF \\011' => '
#
# Stub version of: \\ER\\EF \\011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(32); #  
  $rc .= chr(9); # \\011

  return $rc;
}
',
          '^^!' => '
#
# Stub version of: ^^!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\E\\021$<16*>' => '
#
# Stub version of: \\E\\021$<16*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(17); # \\021
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&dS' => '
#
# Stub version of: \\E&dS
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\r\\ED$<5/>' => '
#
# Stub version of: \\r\\ED$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;m%?%p9%t\\E(0%e\\E(B%;' => '
#
# Stub version of: \\E[%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;%?%p7%t;8%;m%?%p9%t\\E(0%e\\E(B%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;

  return $rc;
}
',
          '\\EFR' => '
#
# Stub version of: \\EFR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[>5l' => '
#
# Stub version of: \\E[>5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p5%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%t;7%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p5%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%t;7%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[0]); # %p1
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\EW$<16>' => '
#
# Stub version of: \\EW$<16>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EF14' => '
#
# Stub version of: \\EF14
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\ESTART\\r\\E70\\,0\\r\\EEND\\r$<20>' => '
#
# Stub version of: \\ESTART\\r\\E70\\,0\\r\\EEND\\r$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(84); # T
  $rc .= chr(65); # A
  $rc .= chr(82); # R
  $rc .= chr(84); # T
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\,
  $rc .= chr(48); # 0
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(78); # N
  $rc .= chr(68); # D
  $rc .= chr(13); # \\r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Eb$<200/>\\Ea' => '
#
# Stub version of: \\Eb$<200/>\\Ea
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\E002' => '
#
# Stub version of: \\E002
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E[%?%p1%t7;%;%?%p2%t4;%;%?%p3%t7;%;%?%p4%t5;%;%?%p6%t1;%;%?%p7%t8;%;m' => '
#
# Stub version of: \\E[%?%p1%t7;%;%?%p2%t4;%;%?%p3%t7;%;%?%p4%t5;%;%?%p6%t1;%;%?%p7%t8;%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(56); # 8
    $rc .= chr(59); # ;
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\r\\n$<11>' => '
#
# Stub version of: \\r\\n$<11>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[M$<4>' => '
#
# Stub version of: \\E[M$<4>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EU!' => '
#
# Stub version of: \\EU!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\E[2;5~' => '
#
# Stub version of: \\E[2;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E4  %p1%{64}%+%c' => '
#
# Stub version of: \\E4  %p1%{64}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  push(@iparam, 64); # %{64}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\ER$<11>' => '
#
# Stub version of: \\ER$<11>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\233%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;m%?%p9%t\\E(0%e\\E(B%;' => '
#
# Stub version of: \\233%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;m%?%p9%t\\E(0%e\\E(B%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;

  return $rc;
}
',
          '\\EI\\EF \\011' => '
#
# Stub version of: \\EI\\EF \\011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(32); #  
  $rc .= chr(9); # \\011

  return $rc;
}
',
          'PF3' => '
#
# Stub version of: PF3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(80); # P
  $rc .= chr(70); # F
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E&f2a%p1%dk%p2%l%Pa%?%ga%t%ga%d%e1%;d0L%?%ga%!%t %;%p2%s' => '
#
# Stub version of: \\E&f2a%p1%dk%p2%l%Pa%?%ga%t%ga%d%e1%;d0L%?%ga%!%t %;%p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(102); # f
  $rc .= chr(50); # 2
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(107); # k
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $dynamicp->[0] = pop(@iparam); # %Pa
  if (do { # %?
           push(@iparam, $dynamicp->[0]); # %ga
           pop(@iparam);
         }) { # %t
    push(@iparam, $dynamicp->[0]); # %ga
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  }
  else { # %e
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(100); # d
  $rc .= chr(48); # 0
  $rc .= chr(76); # L
  if (do { # %?
           push(@iparam, $dynamicp->[0]); # %ga
           push(@iparam, ! pop(@iparam)); # %!
           pop(@iparam);
         }) { # %t
    $rc .= chr(32); #  
  } # %;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '\\EU$<46/>' => '
#
# Stub version of: \\EU$<46/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(54); # 6
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E7\\E[255;0;0;76;134;134p\\E8\\E[J' => '
#
# Stub version of: \\E7\\E[255;0;0;76;134;134p\\E8\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E^P' => '
#
# Stub version of: \\E^P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^P

  return $rc;
}
',
          '\\233102z' => '
#
# Stub version of: \\233102z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E!Y' => '
#
# Stub version of: \\E!Y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(89); # Y

  return $rc;
}
',
          '^S\\Ea' => '
#
# Stub version of: ^S\\Ea
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^S
  $rc .= chr(27); # \\E
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\037up %p1%d\\r' => '
#
# Stub version of: \\037up %p1%d\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(117); # u
  $rc .= chr(112); # p
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[0%?%p6%t;35%;%?%p2%t;36;4%;%?%p1%t;33;44%;%?%p3%t;7%;m' => '
#
# Stub version of: \\E[0%?%p6%t;35%;%?%p2%t;36;4%;%?%p1%t;33;44%;%?%p3%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(51); # 3
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(51); # 3
    $rc .= chr(54); # 6
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(51); # 3
    $rc .= chr(51); # 3
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Ec20' => '
#
# Stub version of: \\Ec20
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\EwG\\Ee($<150>' => '
#
# Stub version of: \\EwG\\Ee($<150>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(40); # (
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E9' => '
#
# Stub version of: \\E9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\EO\\Eq\\EG\\Ev\\EJ\\EY7 K6 MS Kermit 2.27 UCB 227.14 IBM PC 3-17-85\\n' => '
#
# Stub version of: \\EO\\Eq\\EG\\Ev\\EJ\\EY7 K6 MS Kermit 2.27 UCB 227.14 IBM PC 3-17-85\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(75); # K
  $rc .= chr(54); # 6
  $rc .= chr(32); #  
  $rc .= chr(77); # M
  $rc .= chr(83); # S
  $rc .= chr(32); #  
  $rc .= chr(75); # K
  $rc .= chr(101); # e
  $rc .= chr(114); # r
  $rc .= chr(109); # m
  $rc .= chr(105); # i
  $rc .= chr(116); # t
  $rc .= chr(32); #  
  $rc .= chr(50); # 2
  $rc .= chr(46); # .
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(85); # U
  $rc .= chr(67); # C
  $rc .= chr(66); # B
  $rc .= chr(32); #  
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(46); # .
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(32); #  
  $rc .= chr(73); # I
  $rc .= chr(66); # B
  $rc .= chr(77); # M
  $rc .= chr(32); #  
  $rc .= chr(80); # P
  $rc .= chr(67); # C
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(45); # -
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(45); # -
  $rc .= chr(56); # 8
  $rc .= chr(53); # 5
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\En0$<200>\\En1' => '
#
# Stub version of: \\En0$<200>\\En1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(110); # n
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(110); # n
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[24@' => '
#
# Stub version of: \\E[24@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[%p1%dr' => '
#
# Stub version of: \\E[%p1%dr
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\2333~' => '
#
# Stub version of: \\2333~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E^B' => '
#
# Stub version of: \\E^B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^B

  return $rc;
}
',
          '\\E[1;6D' => '
#
# Stub version of: \\E[1;6D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[027q' => '
#
# Stub version of: \\E[027q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\377\\252' => '
#
# Stub version of: \\377\\252
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(170); # \\252

  return $rc;
}
',
          '\\EP2;1~\\E\\\\' => '
#
# Stub version of: \\EP2;1~\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(126); # ~
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E[M$<5*/>' => '
#
# Stub version of: \\E[M$<5*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E_b' => '
#
# Stub version of: \\E_b
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(98); # b

  return $rc;
}
',
          '^^Pd' => '
#
# Stub version of: ^^Pd
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\036$<2>' => '
#
# Stub version of: \\036$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^^X' => '
#
# Stub version of: ^^^X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(0); # ^X

  return $rc;
}
',
          '\\233106z' => '
#
# Stub version of: \\233106z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[?7h\\E[?3l\\E[?5l' => '
#
# Stub version of: \\E[?7h\\E[?3l\\E[?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '^_P' => '
#
# Stub version of: ^_P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^_
  $rc .= chr(80); # P

  return $rc;
}
',
          '^\\011\\r' => '
#
# Stub version of: ^\\011\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(9); # \\011
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\233314z' => '
#
# Stub version of: \\233314z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '^]\\342' => '
#
# Stub version of: ^]\\342
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^]
  $rc .= chr(226); # \\342

  return $rc;
}
',
          '\\E[7l' => '
#
# Stub version of: \\E[7l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[5m$<30>' => '
#
# Stub version of: \\E[5m$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^y' => '
#
# Stub version of: ^^y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(121); # y

  return $rc;
}
',
          '\\002\\E\\177\\003' => '
#
# Stub version of: \\002\\E\\177\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(2); # \\002
  $rc .= chr(27); # \\E
  $rc .= chr(127); # \\177
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '\\E\\:a' => '
#
# Stub version of: \\E\\:a
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\:
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\E[[D' => '
#
# Stub version of: \\E[[D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[106z' => '
#
# Stub version of: \\E[106z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\013$<300/>' => '
#
# Stub version of: \\013$<300/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EOo' => '
#
# Stub version of: \\EOo
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\EL$<5*/>' => '
#
# Stub version of: \\EL$<5*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\001\\E7' => '
#
# Stub version of: \\E\\001\\E7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\E[8;6~' => '
#
# Stub version of: \\E[8;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[?5h\\E[?5l\\E[?5h\\E[?5l\\E[?5h\\E[?5l' => '
#
# Stub version of: \\E[?5h\\E[?5l\\E[?5h\\E[?5l\\E[?5h\\E[?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '``aaffgghhiijjkkllmmnnqqttuuvvwwxxyyzz~~' => '
#
# Stub version of: ``aaffgghhiijjkkllmmnnqqttuuvvwwxxyyzz~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(96); # `
  $rc .= chr(96); # `
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(104); # h
  $rc .= chr(104); # h
  $rc .= chr(105); # i
  $rc .= chr(105); # i
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(121); # y
  $rc .= chr(121); # y
  $rc .= chr(122); # z
  $rc .= chr(122); # z
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E&a%p1%2dY' => '
#
# Stub version of: \\E&a%p1%2dY
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(89); # Y

  return $rc;
}
',
          '\\E[2J\\E8' => '
#
# Stub version of: \\E[2J\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[1;7A' => '
#
# Stub version of: \\E[1;7A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(65); # A

  return $rc;
}
',
          '^P^R' => '
#
# Stub version of: ^P^R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(0); # ^R

  return $rc;
}
',
          '\\E#' => '
#
# Stub version of: \\E#
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #

  return $rc;
}
',
          '\\004$<.1*/>' => '
#
# Stub version of: \\004$<.1*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(4); # \\004
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(46); # .
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[>1;3A' => '
#
# Stub version of: \\E[>1;3A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E\\005$<16*>' => '
#
# Stub version of: \\E\\005$<16*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(5); # \\005
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EOb' => '
#
# Stub version of: \\EOb
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E\\006$<10/>' => '
#
# Stub version of: \\E\\006$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(6); # \\006
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[=1c' => '
#
# Stub version of: \\E[=1c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(99); # c

  return $rc;
}
',
          '^A<2' => '
#
# Stub version of: ^A<2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(60); # <
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E&a0y0C\\EJ' => '
#
# Stub version of: \\E&a0y0C\\EJ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  $rc .= chr(48); # 0
  $rc .= chr(121); # y
  $rc .= chr(48); # 0
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[60;0;0;28p\\E[28;1H\\E[K' => '
#
# Stub version of: \\E[60;0;0;28p\\E[28;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\377\\254' => '
#
# Stub version of: \\377\\254
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(172); # \\254

  return $rc;
}
',
          '\\0n' => '
#
# Stub version of: \\0n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\EG@' => '
#
# Stub version of: \\EG@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[1$}\\E[;%df' => '
#
# Stub version of: \\E[1$}\\E[;%df
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(125); # }
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\EH\\EJ$<132>' => '
#
# Stub version of: \\EH\\EJ$<132>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '^U' => '
#
# Stub version of: ^U
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^U

  return $rc;
}
',
          '\\E;\\EF \\011' => '
#
# Stub version of: \\E;\\EF \\011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(59); # ;
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(32); #  
  $rc .= chr(9); # \\011

  return $rc;
}
',
          '\\EU\\Ef\\E7\\E5\\E8\\El\\ENH\\E\\0\\Eo&\\0\\Eo\'\\E\\Eo!\\0\\E\\007!\\E\\010A@ \\E4#\\:"\\E\\:a\\E4#;"\\E\\:b\\E4#<"\\E\\:c' => '
#
# Stub version of: \\EU\\Ef\\E7\\E5\\E8\\El\\ENH\\E\\0\\Eo&\\0\\Eo\'\\E\\Eo!\\0\\E\\007!\\E\\010A@ \\E4#\\:"\\E\\:a\\E4#;"\\E\\:b\\E4#<"\\E\\:c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(53); # 5
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(111); # o
  $rc .= chr(38); # &
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(111); # o
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(27); # \\E
  $rc .= chr(111); # o
  $rc .= chr(33); # !
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(7); # \\007
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(8); # \\010
  $rc .= chr(65); # A
  $rc .= chr(64); # @
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(35); # #
  $rc .= chr(128); # \\:
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\:
  $rc .= chr(97); # a
  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(35); # #
  $rc .= chr(59); # ;
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\:
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(35); # #
  $rc .= chr(60); # <
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\:
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E[2$~\\n' => '
#
# Stub version of: \\E[2$~\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(126); # ~
  $rc .= chr(10); # \\n

  return $rc;
}
',
          'A delete char' => '
#
# Stub version of: A delete char
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(65); # A
  $rc .= chr(32); #  
  $rc .= chr(100); # d
  $rc .= chr(101); # e
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(116); # t
  $rc .= chr(101); # e
  $rc .= chr(32); #  
  $rc .= chr(99); # c
  $rc .= chr(104); # h
  $rc .= chr(97); # a
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\Es_' => '
#
# Stub version of: \\Es_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(95); # _

  return $rc;
}
',
          '\\ET$<10>' => '
#
# Stub version of: \\ET$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '~$<\\23318>' => '
#
# Stub version of: ~$<\\23318>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\017\\025\\035\\036E\\036O' => '
#
# Stub version of: \\017\\025\\035\\036E\\036O
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(21); # \\025
  $rc .= chr(29); # \\035
  $rc .= chr(30); # \\036
  $rc .= chr(69); # E
  $rc .= chr(30); # \\036
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\EJ$<20*>' => '
#
# Stub version of: \\EJ$<20*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\017\\E0`' => '
#
# Stub version of: \\017\\E0`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(96); # `

  return $rc;
}
',
          '\\241' => '
#
# Stub version of: \\241
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(161); # \\241

  return $rc;
}
',
          '\\E[1;2D' => '
#
# Stub version of: \\E[1;2D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[304z' => '
#
# Stub version of: \\E[304z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '^J\\Eb' => '
#
# Stub version of: ^J\\Eb
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^J
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E[29;1|' => '
#
# Stub version of: \\E[29;1|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\Ez56;2;0;0z\\Ez73z\\Ez4;1;1z' => '
#
# Stub version of: \\Ez56;2;0;0z\\Ez73z\\Ez4;1;1z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(122); # z
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(122); # z
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\036$<10>' => '
#
# Stub version of: \\036$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&v0S' => '
#
# Stub version of: \\E&v0S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(48); # 0
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E[>\\,\\001' => '
#
# Stub version of: \\E[>\\,\\001
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(128); # \\,
  $rc .= chr(1); # \\001

  return $rc;
}
',
          '\\E[X' => '
#
# Stub version of: \\E[X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(88); # X

  return $rc;
}
',
          '\\036FS11' => '
#
# Stub version of: \\036FS11
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(83); # S
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\EPY99\\:98\\E\\\\\\E[0;98v\\E[2J\\E[v' => '
#
# Stub version of: \\EPY99\\:98\\E\\\\\\E[0;98v\\E[2J\\E[v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(89); # Y
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\:
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\Ei7' => '
#
# Stub version of: \\Ei7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(105); # i
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\Eb2' => '
#
# Stub version of: \\Eb2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E[<%?%p1%{0}%=%t0m%e%p1%{1}%=%t4m%e%p1%{2}%=%t3m%e%p1%{3}%=%t5m%e%p1%{4}%=%t2m%e%p1%{5}%=%t6m%e%p1%{6}%=%t7m%e1m%;' => '
#
# Stub version of: \\E[<%?%p1%{0}%=%t0m%e%p1%{1}%=%t4m%e%p1%{2}%=%t3m%e%p1%{3}%=%t5m%e%p1%{4}%=%t2m%e%p1%{5}%=%t6m%e%p1%{6}%=%t7m%e1m%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 1); # %{1}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 2); # %{2}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 5); # %{5}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(109); # m
  }
  else { # %e
    $rc .= chr(49); # 1
    $rc .= chr(109); # m
  } # %;

  return $rc;
}
',
          '\\E\\003\\E!' => '
#
# Stub version of: \\E\\003\\E!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(33); # !

  return $rc;
}
',
          '7' => '
#
# Stub version of: 7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(55); # 7

  return $rc;
}
',
          '^Z9' => '
#
# Stub version of: ^Z9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Z
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\233?5h$<100/>\\233?5l' => '
#
# Stub version of: \\233?5h$<100/>\\233?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EU\\E z"\\Ev\\001\\177 !p\\E ;"\\E z \\Ev  \\001\\177p\\Ep\\n' => '
#
# Stub version of: \\EU\\E z"\\Ev\\001\\177 !p\\E ;"\\E z \\Ev  \\001\\177p\\Ep\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(122); # z
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(1); # \\001
  $rc .= chr(127); # \\177
  $rc .= chr(32); #  
  $rc .= chr(33); # !
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(59); # ;
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(122); # z
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(1); # \\001
  $rc .= chr(127); # \\177
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\E[2w\\E[2!w\\E[1;1;1;80w\\E[H\\E[2*w\\E[1!w\\E2\\r\\n' => '
#
# Stub version of: \\E[2w\\E[2!w\\E[1;1;1;80w\\E[H\\E[2*w\\E[1!w\\E2\\r\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(33); # !
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(33); # !
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\E[H\\E[J$<38>' => '
#
# Stub version of: \\E[H\\E[J$<38>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(56); # 8
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[=15F' => '
#
# Stub version of: \\E[=15F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E&d%{64}%?%p1%t%{66}%|%;%?%p2%t%{68}%|%;%?%p3%t%{66}%|%;%?%p4%t%{65}%|%;%?%p5%t%{72}%|%;%?%p6%t%{66}%|%;%c' => '
#
# Stub version of: \\E&d%{64}%?%p1%t%{66}%|%;%?%p2%t%{68}%|%;%?%p3%t%{66}%|%;%?%p4%t%{65}%|%;%?%p5%t%{72}%|%;%?%p6%t%{66}%|%;%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  push(@iparam, 64); # %{64}
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    push(@iparam, 66); # %{66}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    push(@iparam, 68); # %{68}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    push(@iparam, 66); # %{66}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 65); # %{65}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    push(@iparam, 72); # %{72}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    push(@iparam, 66); # %{66}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\0\\211' => '
#
# Stub version of: \\0\\211
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(137); # \\211

  return $rc;
}
',
          '\\EJ$<120>' => '
#
# Stub version of: \\EJ$<120>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ej\\Ex5\\Ex1\\EY8%+ \\Eo' => '
#
# Stub version of: \\Ej\\Ex5\\Ex1\\EY8%+ \\Eo
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(53); # 5
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(56); # 8
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\E[?25l\\E[?1c' => '
#
# Stub version of: \\E[?25l\\E[?1c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\377\\276' => '
#
# Stub version of: \\377\\276
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(190); # \\276

  return $rc;
}
',
          '\\E[8;4~' => '
#
# Stub version of: \\E[8;4~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\Eh\\Ef' => '
#
# Stub version of: \\Eh\\Ef
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\2337~' => '
#
# Stub version of: \\2337~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(55); # 7
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[1m$<2/>' => '
#
# Stub version of: \\E[1m$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '^B>\\r' => '
#
# Stub version of: ^B>\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(62); # >
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\0\\212' => '
#
# Stub version of: \\0\\212
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(138); # \\212

  return $rc;
}
',
          '\\EcE' => '
#
# Stub version of: \\EcE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\0\\\\' => '
#
# Stub version of: \\0\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\'r0_jhkglfmeniopqksqtmulvownxj' => '
#
# Stub version of: \'r0_jhkglfmeniopqksqtmulvownxj
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(39); # \'
  $rc .= chr(114); # r
  $rc .= chr(48); # 0
  $rc .= chr(95); # _
  $rc .= chr(106); # j
  $rc .= chr(104); # h
  $rc .= chr(107); # k
  $rc .= chr(103); # g
  $rc .= chr(108); # l
  $rc .= chr(102); # f
  $rc .= chr(109); # m
  $rc .= chr(101); # e
  $rc .= chr(110); # n
  $rc .= chr(105); # i
  $rc .= chr(111); # o
  $rc .= chr(112); # p
  $rc .= chr(113); # q
  $rc .= chr(107); # k
  $rc .= chr(115); # s
  $rc .= chr(113); # q
  $rc .= chr(116); # t
  $rc .= chr(109); # m
  $rc .= chr(117); # u
  $rc .= chr(108); # l
  $rc .= chr(118); # v
  $rc .= chr(111); # o
  $rc .= chr(119); # w
  $rc .= chr(110); # n
  $rc .= chr(120); # x
  $rc .= chr(106); # j

  return $rc;
}
',
          '\\E%!1\\E[?6141\\E[m' => '
#
# Stub version of: \\E%!1\\E[?6141\\E[m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\377\\303' => '
#
# Stub version of: \\377\\303
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(195); # \\303

  return $rc;
}
',
          '\\E[r\\E[25;1H' => '
#
# Stub version of: \\E[r\\E[25;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E(\\EG0' => '
#
# Stub version of: \\E(\\EG0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\377\\321' => '
#
# Stub version of: \\377\\321
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(209); # \\321

  return $rc;
}
',
          '\\E[M$<99>' => '
#
# Stub version of: \\E[M$<99>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[m\\016$<1>' => '
#
# Stub version of: \\E[m\\016$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(14); # \\016
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^D^\\' => '
#
# Stub version of: ^^D^\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(68); # D
  $rc .= chr(94); # ^
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[3g\\E[>5g' => '
#
# Stub version of: \\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[3g\\E[>5g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\E[1;5F' => '
#
# Stub version of: \\E[1;5F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\002\\E}\\003' => '
#
# Stub version of: \\002\\E}\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(2); # \\002
  $rc .= chr(27); # \\E
  $rc .= chr(125); # }
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '\\E[36~' => '
#
# Stub version of: \\E[36~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[1;4Q' => '
#
# Stub version of: \\E[1;4Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E\\021%p2%c%p1%{32}%+%c' => '
#
# Stub version of: \\E\\021%p2%c%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(17); # \\021
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[1;3S' => '
#
# Stub version of: \\E[1;3S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E[12\\^' => '
#
# Stub version of: \\E[12\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\EF%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\EF%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E^Y' => '
#
# Stub version of: \\E^Y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^Y

  return $rc;
}
',
          '\\E\\023\\E2' => '
#
# Stub version of: \\E\\023\\E2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(19); # \\023
  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E[0m\\017' => '
#
# Stub version of: \\E[0m\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(109); # m
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\233008z' => '
#
# Stub version of: \\233008z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\Er\\EF \\011' => '
#
# Stub version of: \\Er\\EF \\011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(32); #  
  $rc .= chr(9); # \\011

  return $rc;
}
',
          '^^.' => '
#
# Stub version of: ^^.
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(46); # .

  return $rc;
}
',
          '\\E[2b\\E[u\\r\\E[K' => '
#
# Stub version of: \\E[2b\\E[u\\r\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(117); # u
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\016$<1>' => '
#
# Stub version of: \\016$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '^A8\\r' => '
#
# Stub version of: ^A8\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(56); # 8
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E$P' => '
#
# Stub version of: \\E$P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E~_d\\E[2J' => '
#
# Stub version of: \\E~_d\\E[2J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(95); # _
  $rc .= chr(100); # d
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J

  return $rc;
}
',
          'TAB SET' => '
#
# Stub version of: TAB SET
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(84); # T
  $rc .= chr(65); # A
  $rc .= chr(66); # B
  $rc .= chr(32); #  
  $rc .= chr(83); # S
  $rc .= chr(69); # E
  $rc .= chr(84); # T

  return $rc;
}
',
          '%?%p1%{0}%=%tusascii%e%p1%{1}%=%tenglish%e%p1%{2}%=%tfinnish%e%p1%{3}%=%tjapanese%e%p1%{4}%=%tnorwegian%e%p1%{5}%=%tswedish%e%p1%{6}%=%tgermanic%e%p1%{7}%=%tfrench%e%p1%{8}%=%tcanadian_french%e%p1%{9}%=%titalian%e%p1%{10}%=%tspanish%e%p1%{11}%=%tline%e%p1%{12}%=%tsecurity%e%p1%{13}%=%tebcdic%e%p1%{14}%=%tapl%e%p1%{15}%=%tmosaic%;' => '
#
# Stub version of: %?%p1%{0}%=%tusascii%e%p1%{1}%=%tenglish%e%p1%{2}%=%tfinnish%e%p1%{3}%=%tjapanese%e%p1%{4}%=%tnorwegian%e%p1%{5}%=%tswedish%e%p1%{6}%=%tgermanic%e%p1%{7}%=%tfrench%e%p1%{8}%=%tcanadian_french%e%p1%{9}%=%titalian%e%p1%{10}%=%tspanish%e%p1%{11}%=%tline%e%p1%{12}%=%tsecurity%e%p1%{13}%=%tebcdic%e%p1%{14}%=%tapl%e%p1%{15}%=%tmosaic%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(117); # u
    $rc .= chr(115); # s
    $rc .= chr(97); # a
    $rc .= chr(115); # s
    $rc .= chr(99); # c
    $rc .= chr(105); # i
    $rc .= chr(105); # i
  } # %;
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 1); # %{1}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(101); # e
    $rc .= chr(110); # n
    $rc .= chr(103); # g
    $rc .= chr(108); # l
    $rc .= chr(105); # i
    $rc .= chr(115); # s
    $rc .= chr(104); # h
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 2); # %{2}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(102); # f
    $rc .= chr(105); # i
    $rc .= chr(110); # n
    $rc .= chr(110); # n
    $rc .= chr(105); # i
    $rc .= chr(115); # s
    $rc .= chr(104); # h
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(106); # j
    $rc .= chr(97); # a
    $rc .= chr(112); # p
    $rc .= chr(97); # a
    $rc .= chr(110); # n
    $rc .= chr(101); # e
    $rc .= chr(115); # s
    $rc .= chr(101); # e
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(110); # n
    $rc .= chr(111); # o
    $rc .= chr(114); # r
    $rc .= chr(119); # w
    $rc .= chr(101); # e
    $rc .= chr(103); # g
    $rc .= chr(105); # i
    $rc .= chr(97); # a
    $rc .= chr(110); # n
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 5); # %{5}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(115); # s
    $rc .= chr(119); # w
    $rc .= chr(101); # e
    $rc .= chr(100); # d
    $rc .= chr(105); # i
    $rc .= chr(115); # s
    $rc .= chr(104); # h
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(103); # g
    $rc .= chr(101); # e
    $rc .= chr(114); # r
    $rc .= chr(109); # m
    $rc .= chr(97); # a
    $rc .= chr(110); # n
    $rc .= chr(105); # i
    $rc .= chr(99); # c
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 7); # %{7}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(102); # f
    $rc .= chr(114); # r
    $rc .= chr(101); # e
    $rc .= chr(110); # n
    $rc .= chr(99); # c
    $rc .= chr(104); # h
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 8); # %{8}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(99); # c
    $rc .= chr(97); # a
    $rc .= chr(110); # n
    $rc .= chr(97); # a
    $rc .= chr(100); # d
    $rc .= chr(105); # i
    $rc .= chr(97); # a
    $rc .= chr(110); # n
    $rc .= chr(95); # _
    $rc .= chr(102); # f
    $rc .= chr(114); # r
    $rc .= chr(101); # e
    $rc .= chr(110); # n
    $rc .= chr(99); # c
    $rc .= chr(104); # h
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 9); # %{9}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(105); # i
    $rc .= chr(116); # t
    $rc .= chr(97); # a
    $rc .= chr(108); # l
    $rc .= chr(105); # i
    $rc .= chr(97); # a
    $rc .= chr(110); # n
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 10); # %{10}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(115); # s
    $rc .= chr(112); # p
    $rc .= chr(97); # a
    $rc .= chr(110); # n
    $rc .= chr(105); # i
    $rc .= chr(115); # s
    $rc .= chr(104); # h
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 11); # %{11}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(108); # l
    $rc .= chr(105); # i
    $rc .= chr(110); # n
    $rc .= chr(101); # e
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 12); # %{12}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(115); # s
    $rc .= chr(101); # e
    $rc .= chr(99); # c
    $rc .= chr(117); # u
    $rc .= chr(114); # r
    $rc .= chr(105); # i
    $rc .= chr(116); # t
    $rc .= chr(121); # y
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 13); # %{13}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(101); # e
    $rc .= chr(98); # b
    $rc .= chr(99); # c
    $rc .= chr(100); # d
    $rc .= chr(105); # i
    $rc .= chr(99); # c
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 14); # %{14}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(97); # a
    $rc .= chr(112); # p
    $rc .= chr(108); # l
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 15); # %{15}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(109); # m
    $rc .= chr(111); # o
    $rc .= chr(115); # s
    $rc .= chr(97); # a
    $rc .= chr(105); # i
    $rc .= chr(99); # c
  }

  return $rc;
}
',
          '\\E[76p' => '
#
# Stub version of: \\E[76p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(54); # 6
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\0g' => '
#
# Stub version of: \\0g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\E[41~' => '
#
# Stub version of: \\E[41~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[01s' => '
#
# Stub version of: \\E[01s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E\\001\\E@' => '
#
# Stub version of: \\E\\001\\E@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\EM' => '
#
# Stub version of: \\EM
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\Eq\\r' => '
#
# Stub version of: \\Eq\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^^PB' => '
#
# Stub version of: ^^PB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[5m$<200/>\\E[m' => '
#
# Stub version of: \\E[5m$<200/>\\E[m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[35h\\E[?3l' => '
#
# Stub version of: \\E[35h\\E[?3l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[=C' => '
#
# Stub version of: \\E[=C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\377\\263' => '
#
# Stub version of: \\377\\263
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(179); # \\263

  return $rc;
}
',
          '\\EPB' => '
#
# Stub version of: \\EPB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(66); # B

  return $rc;
}
',
          '^Z' => '
#
# Stub version of: ^Z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Z

  return $rc;
}
',
          '\\Ef\\EG0' => '
#
# Stub version of: \\Ef\\EG0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[?6h\\E%!0\\ELBP0\\E%!1\\E[32;1f' => '
#
# Stub version of: \\E[?6h\\E%!0\\ELBP0\\E%!1\\E[32;1f
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(80); # P
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(102); # f

  return $rc;
}
',
          'F4' => '
#
# Stub version of: F4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\E7\\E[60;0;0;18p\\E8' => '
#
# Stub version of: \\E7\\E[60;0;0;18p\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E(B$<4>' => '
#
# Stub version of: \\E(B$<4>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Eq\\EF \\011' => '
#
# Stub version of: \\Eq\\EF \\011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(32); #  
  $rc .= chr(9); # \\011

  return $rc;
}
',
          '\\E[0;10m' => '
#
# Stub version of: \\E[0;10m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[%gh%{4}%^%Ph%gh%dZZ' => '
#
# Stub version of: \\E[%gh%{4}%^%Ph%gh%dZZ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $dynamicp->[7]); # %gh
  push(@iparam, 4); # %{4}
  push(@iparam, pop(@iparam) ^ pop(@iparam)); # %^
  $dynamicp->[7] = pop(@iparam); # %Ph
  push(@iparam, $dynamicp->[7]); # %gh
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(90); # Z
  $rc .= chr(90); # Z

  return $rc;
}
',
          'f9' => '
#
# Stub version of: f9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(102); # f
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\016h\\013j\\001k\\022l\\002m' => '
#
# Stub version of: \\016h\\013j\\001k\\022l\\002m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  $rc .= chr(104); # h
  $rc .= chr(11); # \\013
  $rc .= chr(106); # j
  $rc .= chr(1); # \\001
  $rc .= chr(107); # k
  $rc .= chr(18); # \\022
  $rc .= chr(108); # l
  $rc .= chr(2); # \\002
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\031$<40>' => '
#
# Stub version of: \\031$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(25); # \\031
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[H\\E[1;24;1;132w' => '
#
# Stub version of: \\E[H\\E[1;24;1;132w
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\E[!p\\E[?3;7;19;67h\\E[?1;4l\\E(B\\E)0\\017\\E[2J\\E[1;1H\\E>$<200>' => '
#
# Stub version of: \\E[!p\\E[?3;7;19;67h\\E[?1;4l\\E(B\\E)0\\017\\E[2J\\E[1;1H\\E>$<200>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(33); # !
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EAA' => '
#
# Stub version of: \\EAA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(65); # A

  return $rc;
}
',
          'F11' => '
#
# Stub version of: F11
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\014$<10*/>' => '
#
# Stub version of: \\014$<10*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[035q' => '
#
# Stub version of: \\E[035q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\233%p1%dS' => '
#
# Stub version of: \\233%p1%dS
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(83); # S

  return $rc;
}
',
          '%p1%c\\E[%p2%db$<1*/>' => '
#
# Stub version of: %p1%c\\E[%p2%db$<1*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(98); # b
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[>59l$<100>\\E[>59h' => '
#
# Stub version of: \\E[>59l$<100>\\E[>59h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(57); # 9
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(57); # 9
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E<\\E=\\E[?3l\\E[?7l\\E(B\\E[J\\E7\\E[;r\\E8\\E[m\\E[q' => '
#
# Stub version of: \\E<\\E=\\E[?3l\\E[?7l\\E(B\\E[J\\E7\\E[;r\\E8\\E[m\\E[q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[=%?%p1%{0}%=%t0m%e%p1%{1}%=%t4m%e%p1%{2}%=%t3m%e%p1%{3}%=%t5m%e%p1%{4}%=%t2m%e%p1%{5}%=%t6m%e%p1%{6}%=%t7m%e1m%;' => '
#
# Stub version of: \\E[=%?%p1%{0}%=%t0m%e%p1%{1}%=%t4m%e%p1%{2}%=%t3m%e%p1%{3}%=%t5m%e%p1%{4}%=%t2m%e%p1%{5}%=%t6m%e%p1%{6}%=%t7m%e1m%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 1); # %{1}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 2); # %{2}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 5); # %{5}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
    $rc .= chr(109); # m
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(109); # m
  }
  else { # %e
    $rc .= chr(49); # 1
    $rc .= chr(109); # m
  } # %;

  return $rc;
}
',
          '\\E[=10L' => '
#
# Stub version of: \\E[=10L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\E7\\E[255;0;0;44;97;100p\\E8\\E[J' => '
#
# Stub version of: \\E7\\E[255;0;0;44;97;100p\\E8\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E#P' => '
#
# Stub version of: \\E#P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(80); # P

  return $rc;
}
',
          '^V^I' => '
#
# Stub version of: ^V^I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(0); # ^I

  return $rc;
}
',
          '\\Eo\\r' => '
#
# Stub version of: \\Eo\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(111); # o
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E;0' => '
#
# Stub version of: \\E;0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E*dR' => '
#
# Stub version of: \\E*dR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(42); # *
  $rc .= chr(100); # d
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[7m\\E7\\E[H\\E9\\E8' => '
#
# Stub version of: \\E[7m\\E7\\E[H\\E9\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[11m' => '
#
# Stub version of: \\E[11m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E\\ES0' => '
#
# Stub version of: \\E\\ES0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[%p1%dC$<5>' => '
#
# Stub version of: \\E[%p1%dC$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '^_#' => '
#
# Stub version of: ^_#
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^_
  $rc .= chr(35); # #

  return $rc;
}
',
          '\\035dch 80;' => '
#
# Stub version of: \\035dch 80;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(100); # d
  $rc .= chr(99); # c
  $rc .= chr(104); # h
  $rc .= chr(32); #  
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[t' => '
#
# Stub version of: \\E[t
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(116); # t

  return $rc;
}
',
          'PF8' => '
#
# Stub version of: PF8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(80); # P
  $rc .= chr(70); # F
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\EF05' => '
#
# Stub version of: \\EF05
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E`\\:\\E`9\\017\\Er' => '
#
# Stub version of: \\E`\\:\\E`9\\017\\Er
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\014$<16*/>' => '
#
# Stub version of: \\014$<16*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^f' => '
#
# Stub version of: ^^f
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\E[8r' => '
#
# Stub version of: \\E[8r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\032$<50>\\EK\\E=7\\s' => '
#
# Stub version of: \\032$<50>\\EK\\E=7\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(26); # \\032
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(55); # 7
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E[0%?%p6%t;33%;%?%p2%t;34%;%?%p1%t;31;47%;%?%p3%t;7%;m' => '
#
# Stub version of: \\E[0%?%p6%t;33%;%?%p2%t;34%;%?%p1%t;31;47%;%?%p3%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(51); # 3
    $rc .= chr(51); # 3
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(51); # 3
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(51); # 3
    $rc .= chr(49); # 1
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '^\\006\\r' => '
#
# Stub version of: ^\\006\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(6); # \\006
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Ej\\EY?%+ \\Eo' => '
#
# Stub version of: \\Ej\\EY?%+ \\Eo
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(63); # ?
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(111); # o

  return $rc;
}
',
          '+g\\,h-f.e`bhrisjjkkllmmnnqqttuuvvwwxx{{||}}~~' => '
#
# Stub version of: +g\\,h-f.e`bhrisjjkkllmmnnqqttuuvvwwxx{{||}}~~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(103); # g
  $rc .= chr(128); # \\,
  $rc .= chr(104); # h
  $rc .= chr(45); # -
  $rc .= chr(102); # f
  $rc .= chr(46); # .
  $rc .= chr(101); # e
  $rc .= chr(96); # `
  $rc .= chr(98); # b
  $rc .= chr(104); # h
  $rc .= chr(114); # r
  $rc .= chr(105); # i
  $rc .= chr(115); # s
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x
  $rc .= chr(123); # {
  $rc .= chr(123); # {
  $rc .= chr(124); # |
  $rc .= chr(124); # |
  $rc .= chr(125); # }
  $rc .= chr(125); # }
  $rc .= chr(126); # ~
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\002\\Eq\\003' => '
#
# Stub version of: \\002\\Eq\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(2); # \\002
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '\\EFx' => '
#
# Stub version of: \\EFx
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\E=%p1%{32}%+%c%p2%{32}%+%c$<40>' => '
#
# Stub version of: \\E=%p1%{32}%+%c%p2%{32}%+%c$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^\'' => '
#
# Stub version of: ^^\'
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(39); # \'

  return $rc;
}
',
          'A ce of/cf gn' => '
#
# Stub version of: A ce of/cf gn
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(65); # A
  $rc .= chr(32); #  
  $rc .= chr(99); # c
  $rc .= chr(101); # e
  $rc .= chr(32); #  
  $rc .= chr(111); # o
  $rc .= chr(102); # f
  $rc .= chr(47); # /
  $rc .= chr(99); # c
  $rc .= chr(102); # f
  $rc .= chr(32); #  
  $rc .= chr(103); # g
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\E[167q' => '
#
# Stub version of: \\E[167q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(55); # 7
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m%?%p9%t\\016%e\\017%;$<2>' => '
#
# Stub version of: \\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m%?%p9%t\\016%e\\017%;$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '^\\005\\r' => '
#
# Stub version of: ^\\005\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(5); # \\005
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[1;7m$<2>' => '
#
# Stub version of: \\E[1;7m$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EE$<14>' => '
#
# Stub version of: \\EE$<14>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO1;3B' => '
#
# Stub version of: \\EO1;3B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(66); # B

  return $rc;
}
',
          '^\\HP' => '
#
# Stub version of: ^\\HP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(92); # \\
  $rc .= chr(72); # H
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[>1;4D' => '
#
# Stub version of: \\E[>1;4D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;11%;m' => '
#
# Stub version of: \\E[0;10%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p6%t;1%;%?%p7%t;8%;%?%p9%t;11%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '^R^I' => '
#
# Stub version of: ^R^I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^R
  $rc .= chr(0); # ^I

  return $rc;
}
',
          '\\E[H\\E[2J$<50>' => '
#
# Stub version of: \\E[H\\E[2J$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E%\\E!1\\E[1;32r\\E[?6l\\E>' => '
#
# Stub version of: \\E%\\E!1\\E[1;32r\\E[?6l\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1;5R' => '
#
# Stub version of: \\E[1;5R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\n$<2>' => '
#
# Stub version of: \\n$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[>52h' => '
#
# Stub version of: \\E[>52h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\Ej%p1%d;' => '
#
# Stub version of: \\Ej%p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E\\003\\E@' => '
#
# Stub version of: \\E\\003\\E@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[3;2~' => '
#
# Stub version of: \\E[3;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\025\\E\\004\\027\\030' => '
#
# Stub version of: \\025\\E\\004\\027\\030
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(21); # \\025
  $rc .= chr(27); # \\E
  $rc .= chr(4); # \\004
  $rc .= chr(23); # \\027
  $rc .= chr(24); # \\030

  return $rc;
}
',
          '^AK\\r' => '
#
# Stub version of: ^AK\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(75); # K
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\r\\n\\E[A\\E7\\E[255;1;0;76;178;178p\\E8\\E[J' => '
#
# Stub version of: \\r\\n\\E[A\\E7\\E[255;1;0;76;178;178p\\E8\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(56); # 8
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[;%p1%dr' => '
#
# Stub version of: \\E[;%p1%dr
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\377\\203' => '
#
# Stub version of: \\377\\203
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(131); # \\203

  return $rc;
}
',
          '\\037$<2.2*/>' => '
#
# Stub version of: \\037$<2.2*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(46); # .
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\204' => '
#
# Stub version of: \\204
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(132); # \\204

  return $rc;
}
',
          '\\Em%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\Em%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\Er\\r' => '
#
# Stub version of: \\Er\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E4D' => '
#
# Stub version of: \\E4D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(68); # D

  return $rc;
}
',
          '^\\041\\r' => '
#
# Stub version of: ^\\041\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(33); # \\041
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[36;4m' => '
#
# Stub version of: \\E[36;4m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Ef7' => '
#
# Stub version of: \\Ef7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\E[06s' => '
#
# Stub version of: \\E[06s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\017$<3>' => '
#
# Stub version of: \\017$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ET$<15>' => '
#
# Stub version of: \\ET$<15>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[3$' => '
#
# Stub version of: \\E[3$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\EI\\E\\\\' => '
#
# Stub version of: \\EI\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E[=2c' => '
#
# Stub version of: \\E[=2c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(50); # 2
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E\\001\\E6' => '
#
# Stub version of: \\E\\001\\E6
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E=%p1%{32}%+%c%p2%{32}%+%c$<1>' => '
#
# Stub version of: \\E=%p1%{32}%+%c%p2%{32}%+%c$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?2i' => '
#
# Stub version of: \\E[?2i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\E[3;2;2;1;1;1v\\E(B\\E)4\\017' => '
#
# Stub version of: \\E[3;2;2;1;1;1v\\E(B\\E)4\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(52); # 4
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\EV\\EB' => '
#
# Stub version of: \\EV\\EB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(86); # V
  $rc .= chr(27); # \\E
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E%!1\\E[7m$<2>\\E%!0' => '
#
# Stub version of: \\E%!1\\E[7m$<2>\\E%!0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\Ef1' => '
#
# Stub version of: \\Ef1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[?T' => '
#
# Stub version of: \\E[?T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\EGB\\E(@B@@\\E)' => '
#
# Stub version of: \\EGB\\E(@B@@\\E)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(64); # @
  $rc .= chr(66); # B
  $rc .= chr(64); # @
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )

  return $rc;
}
',
          '\\035rig;' => '
#
# Stub version of: \\035rig;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(114); # r
  $rc .= chr(105); # i
  $rc .= chr(103); # g
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\035dch;' => '
#
# Stub version of: \\035dch;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(100); # d
  $rc .= chr(99); # c
  $rc .= chr(104); # h
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E\\:b' => '
#
# Stub version of: \\E\\:b
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\:
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\233L' => '
#
# Stub version of: \\233L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\2338~' => '
#
# Stub version of: \\2338~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(56); # 8
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\ER$<2>' => '
#
# Stub version of: \\ER$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '^M\\ED' => '
#
# Stub version of: ^M\\ED
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^M
  $rc .= chr(27); # \\E
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[D' => '
#
# Stub version of: \\E[D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[P' => '
#
# Stub version of: \\E[P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[27~' => '
#
# Stub version of: \\E[27~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[L$<3>' => '
#
# Stub version of: \\E[L$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[000z' => '
#
# Stub version of: \\E[000z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EE$<500/>' => '
#
# Stub version of: \\EE$<500/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EY%p1%{32}%+%c%p2%{32}%+%c$<50>' => '
#
# Stub version of: \\EY%p1%{32}%+%c%p2%{32}%+%c$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E7\\E[99;%i%p1%dH' => '
#
# Stub version of: \\E7\\E[99;%i%p1%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          'jjkkllmmnnqqttuuvvwwxx' => '
#
# Stub version of: jjkkllmmnnqqttuuvvwwxx
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\E$I' => '
#
# Stub version of: \\E$I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\ENS' => '
#
# Stub version of: \\ENS
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E[3A' => '
#
# Stub version of: \\E[3A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[P$<7/>' => '
#
# Stub version of: \\E[P$<7/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ey$<130>' => '
#
# Stub version of: \\Ey$<130>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%p1%d;00q%p2%:-16s' => '
#
# Stub version of: \\E[%p1%d;00q%p2%:-16s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(113); # q
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%-16s\', pop(@iparam)); # %-16s

  return $rc;
}
',
          '\\E[17\\^' => '
#
# Stub version of: \\E[17\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\E[%p1%dF' => '
#
# Stub version of: \\E[%p1%dF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\233%p1%dB' => '
#
# Stub version of: \\233%p1%dB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\EFf' => '
#
# Stub version of: \\EFf
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\E[012z' => '
#
# Stub version of: \\E[012z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '+\\020\\,\\021-\\030.^Y0\\333`\\004a\\013f\\370g\\361h\\260i\\316j\\211k\\214l\\206m\\203n\\305o~p\\304q\\212r\\304s_t\\207u\\215v\\301w\\302x\\205y\\363z\\362{\\343|\\330}\\234~\\376' => '
#
# Stub version of: +\\020\\,\\021-\\030.^Y0\\333`\\004a\\013f\\370g\\361h\\260i\\316j\\211k\\214l\\206m\\203n\\305o~p\\304q\\212r\\304s_t\\207u\\215v\\301w\\302x\\205y\\363z\\362{\\343|\\330}\\234~\\376
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(16); # \\020
  $rc .= chr(128); # \\,
  $rc .= chr(17); # \\021
  $rc .= chr(45); # -
  $rc .= chr(24); # \\030
  $rc .= chr(46); # .
  $rc .= chr(0); # ^Y
  $rc .= chr(48); # 0
  $rc .= chr(219); # \\333
  $rc .= chr(96); # `
  $rc .= chr(4); # \\004
  $rc .= chr(97); # a
  $rc .= chr(11); # \\013
  $rc .= chr(102); # f
  $rc .= chr(248); # \\370
  $rc .= chr(103); # g
  $rc .= chr(241); # \\361
  $rc .= chr(104); # h
  $rc .= chr(176); # \\260
  $rc .= chr(105); # i
  $rc .= chr(206); # \\316
  $rc .= chr(106); # j
  $rc .= chr(137); # \\211
  $rc .= chr(107); # k
  $rc .= chr(140); # \\214
  $rc .= chr(108); # l
  $rc .= chr(134); # \\206
  $rc .= chr(109); # m
  $rc .= chr(131); # \\203
  $rc .= chr(110); # n
  $rc .= chr(197); # \\305
  $rc .= chr(111); # o
  $rc .= chr(126); # ~
  $rc .= chr(112); # p
  $rc .= chr(196); # \\304
  $rc .= chr(113); # q
  $rc .= chr(138); # \\212
  $rc .= chr(114); # r
  $rc .= chr(196); # \\304
  $rc .= chr(115); # s
  $rc .= chr(95); # _
  $rc .= chr(116); # t
  $rc .= chr(135); # \\207
  $rc .= chr(117); # u
  $rc .= chr(141); # \\215
  $rc .= chr(118); # v
  $rc .= chr(193); # \\301
  $rc .= chr(119); # w
  $rc .= chr(194); # \\302
  $rc .= chr(120); # x
  $rc .= chr(133); # \\205
  $rc .= chr(121); # y
  $rc .= chr(243); # \\363
  $rc .= chr(122); # z
  $rc .= chr(242); # \\362
  $rc .= chr(123); # {
  $rc .= chr(227); # \\343
  $rc .= chr(124); # |
  $rc .= chr(216); # \\330
  $rc .= chr(125); # }
  $rc .= chr(156); # \\234
  $rc .= chr(126); # ~
  $rc .= chr(254); # \\376

  return $rc;
}
',
          '\\E[1;3R' => '
#
# Stub version of: \\E[1;3R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[0%?%p5%p6%|%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%p6%|%t;7%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p5%p6%|%t;2%;%?%p2%t;4%;%?%p4%t;5%;%?%p3%p1%|%p6%|%t;7%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[0]); # %p1
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\E&d@%{0}%PA%{0}%PB%{0}%PH' => '
#
# Stub version of: \\E&d@%{0}%PA%{0}%PB%{0}%PH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(64); # @
  push(@iparam, 0); # %{0}
  $staticp->[0] = pop(@iparam); # %PA
  push(@iparam, 0); # %{0}
  $staticp->[1] = pop(@iparam); # %PB
  push(@iparam, 0); # %{0}
  $staticp->[7] = pop(@iparam); # %PH

  return $rc;
}
',
          '^B4\\r' => '
#
# Stub version of: ^B4\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(52); # 4
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\233109z' => '
#
# Stub version of: \\233109z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(57); # 9
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[[B' => '
#
# Stub version of: \\E[[B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(66); # B

  return $rc;
}
',
          'R$<\\217>' => '
#
# Stub version of: R$<\\217>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(143); # \\217
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E2' => '
#
# Stub version of: \\E2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E;iYA\\E;jYC' => '
#
# Stub version of: \\E;iYA\\E;jYC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(59); # ;
  $rc .= chr(105); # i
  $rc .= chr(89); # Y
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(59); # ;
  $rc .= chr(106); # j
  $rc .= chr(89); # Y
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E\\003\\E7' => '
#
# Stub version of: \\E\\003\\E7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\E[P$<7>' => '
#
# Stub version of: \\E[P$<7>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(62); # >

  return $rc;
}
',
          '~$<\\23320>' => '
#
# Stub version of: ~$<\\23320>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\320' => '
#
# Stub version of: \\377\\320
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(208); # \\320

  return $rc;
}
',
          '\\EK$<1>' => '
#
# Stub version of: \\EK$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\0' => '
#
# Stub version of: \\E\\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\0

  return $rc;
}
',
          '\\23334~' => '
#
# Stub version of: \\23334~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^^FF' => '
#
# Stub version of: ^^FF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(70); # F
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\Eb@\\EcO' => '
#
# Stub version of: \\Eb@\\EcO
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\E[<12h' => '
#
# Stub version of: \\E[<12h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\EA31' => '
#
# Stub version of: \\EA31
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[4;2m' => '
#
# Stub version of: \\E[4;2m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\ENe' => '
#
# Stub version of: \\ENe
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\ENl' => '
#
# Stub version of: \\ENl
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E0A\\E)' => '
#
# Stub version of: \\E0A\\E)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )

  return $rc;
}
',
          '\\E+' => '
#
# Stub version of: \\E+
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(43); # +

  return $rc;
}
',
          '\\E[24;6~' => '
#
# Stub version of: \\E[24;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EM$<14/>' => '
#
# Stub version of: \\EM$<14/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\013$<5>' => '
#
# Stub version of: \\013$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '^F' => '
#
# Stub version of: ^F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^F

  return $rc;
}
',
          '^P\\0\\0' => '
#
# Stub version of: ^P\\0\\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0

  return $rc;
}
',
          '\\EW$<9>' => '
#
# Stub version of: \\EW$<9>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(57); # 9
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ENH' => '
#
# Stub version of: \\ENH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\EO$<3*/>' => '
#
# Stub version of: \\EO$<3*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E^I' => '
#
# Stub version of: \\E^I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^I

  return $rc;
}
',
          '\\E4%?%p1%t %p1%{32}%+%c%e!\'%;@' => '
#
# Stub version of: \\E4%?%p1%t %p1%{32}%+%c%e!\'%;@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(32); #  
    push(@iparam, $param[0]); # %p1
    push(@iparam, 32); # %{32}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  }
  else { # %e
    $rc .= chr(33); # !
    $rc .= chr(39); # \'
  } # %;
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E#B' => '
#
# Stub version of: \\E#B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E?s' => '
#
# Stub version of: \\E?s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E&a%p1%dY$<6/>' => '
#
# Stub version of: \\E&a%p1%dY$<6/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(89); # Y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ed.' => '
#
# Stub version of: \\Ed.
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(46); # .

  return $rc;
}
',
          '\\E[0;2m' => '
#
# Stub version of: \\E[0;2m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EO0' => '
#
# Stub version of: \\EO0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\011$<3>' => '
#
# Stub version of: \\011$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(9); # \\011
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\242' => '
#
# Stub version of: \\377\\242
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(162); # \\242

  return $rc;
}
',
          '\\E7\\E[1;%p1%dH\\E[1K' => '
#
# Stub version of: \\E7\\E[1;%p1%dH\\E[1K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(75); # K

  return $rc;
}
',
          '$<7/>' => '
#
# Stub version of: $<7/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E006' => '
#
# Stub version of: \\E006
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6

  return $rc;
}
',
          '\\E[21s' => '
#
# Stub version of: \\E[21s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\EH\\EJ$<50/>' => '
#
# Stub version of: \\EH\\EJ$<50/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0J$<20/>' => '
#
# Stub version of: \\E[0J$<20/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[006q' => '
#
# Stub version of: \\E[006q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\ENO' => '
#
# Stub version of: \\ENO
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\E[3;2;2;0;1;0v\\E(0\\017' => '
#
# Stub version of: \\E[3;2;2;0;1;0v\\E(0\\017
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(48); # 0
  $rc .= chr(15); # \\017

  return $rc;
}
',
          '\\E[0~' => '
#
# Stub version of: \\E[0~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[1;3B' => '
#
# Stub version of: \\E[1;3B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(66); # B

  return $rc;
}
',
          '+\\257\\,\\256-\\^0\\333`\\004a\\261f\\370g\\361h\\260j\\331k\\277l\\332m\\300n\\305o~p\\304q\\304r\\304s_t\\303u\\264v\\301w\\302x\\263y\\363z\\362{\\343|\\330}\\234~\\376' => '
#
# Stub version of: +\\257\\,\\256-\\^0\\333`\\004a\\261f\\370g\\361h\\260j\\331k\\277l\\332m\\300n\\305o~p\\304q\\304r\\304s_t\\303u\\264v\\301w\\302x\\263y\\363z\\362{\\343|\\330}\\234~\\376
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(175); # \\257
  $rc .= chr(128); # \\,
  $rc .= chr(174); # \\256
  $rc .= chr(45); # -
  $rc .= chr(128); # \\^
  $rc .= chr(48); # 0
  $rc .= chr(219); # \\333
  $rc .= chr(96); # `
  $rc .= chr(4); # \\004
  $rc .= chr(97); # a
  $rc .= chr(177); # \\261
  $rc .= chr(102); # f
  $rc .= chr(248); # \\370
  $rc .= chr(103); # g
  $rc .= chr(241); # \\361
  $rc .= chr(104); # h
  $rc .= chr(176); # \\260
  $rc .= chr(106); # j
  $rc .= chr(217); # \\331
  $rc .= chr(107); # k
  $rc .= chr(191); # \\277
  $rc .= chr(108); # l
  $rc .= chr(218); # \\332
  $rc .= chr(109); # m
  $rc .= chr(192); # \\300
  $rc .= chr(110); # n
  $rc .= chr(197); # \\305
  $rc .= chr(111); # o
  $rc .= chr(126); # ~
  $rc .= chr(112); # p
  $rc .= chr(196); # \\304
  $rc .= chr(113); # q
  $rc .= chr(196); # \\304
  $rc .= chr(114); # r
  $rc .= chr(196); # \\304
  $rc .= chr(115); # s
  $rc .= chr(95); # _
  $rc .= chr(116); # t
  $rc .= chr(195); # \\303
  $rc .= chr(117); # u
  $rc .= chr(180); # \\264
  $rc .= chr(118); # v
  $rc .= chr(193); # \\301
  $rc .= chr(119); # w
  $rc .= chr(194); # \\302
  $rc .= chr(120); # x
  $rc .= chr(179); # \\263
  $rc .= chr(121); # y
  $rc .= chr(243); # \\363
  $rc .= chr(122); # z
  $rc .= chr(242); # \\362
  $rc .= chr(123); # {
  $rc .= chr(227); # \\343
  $rc .= chr(124); # |
  $rc .= chr(216); # \\330
  $rc .= chr(125); # }
  $rc .= chr(156); # \\234
  $rc .= chr(126); # ~
  $rc .= chr(254); # \\376

  return $rc;
}
',
          '\\E[4h\\E[2Q' => '
#
# Stub version of: \\E[4h\\E[2Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\Ez4;2;1z\\Ez56;2;80;24z' => '
#
# Stub version of: \\Ez4;2;1z\\Ez56;2;80;24z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(122); # z
  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EFU' => '
#
# Stub version of: \\EFU
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(85); # U

  return $rc;
}
',
          '\\377\\216' => '
#
# Stub version of: \\377\\216
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(142); # \\216

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dH' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\Em^L' => '
#
# Stub version of: \\Em^L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(0); # ^L

  return $rc;
}
',
          '\\E[0;37;40m' => '
#
# Stub version of: \\E[0;37;40m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[6D' => '
#
# Stub version of: \\E[6D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\Ec\\E[?7h\\E[>5g' => '
#
# Stub version of: \\Ec\\E[?7h\\E[>5g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\035dli %p1%d;' => '
#
# Stub version of: \\035dli %p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(100); # d
  $rc .= chr(108); # l
  $rc .= chr(105); # i
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E>\\E(B\\E)0\\017\\E[m' => '
#
# Stub version of: \\E>\\E(B\\E)0\\017\\E[m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\217S' => '
#
# Stub version of: \\217S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\2330$}' => '
#
# Stub version of: \\2330$}
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(125); # }

  return $rc;
}
',
          '\\036W =\\036U' => '
#
# Stub version of: \\036W =\\036U
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(87); # W
  $rc .= chr(32); #  
  $rc .= chr(61); # =
  $rc .= chr(30); # \\036
  $rc .= chr(85); # U

  return $rc;
}
',
          '^V9' => '
#
# Stub version of: ^V9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(57); # 9

  return $rc;
}
',
          '%?%p9%t\\E(0%e\\E(B%;\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;m' => '
#
# Stub version of: %?%p9%t\\E(0%e\\E(B%;\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EI$<2*/>' => '
#
# Stub version of: \\EI$<2*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[11;2|' => '
#
# Stub version of: \\E[11;2|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\E[=11L' => '
#
# Stub version of: \\E[=11L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\E[%?%p1%{8}%<%t4%p1%d%e%p1%{16}%<%t10%p1%{8}%-%d%e48;5;%p1%d%;m' => '
#
# Stub version of: \\E[%?%p1%{8}%<%t4%p1%d%e%p1%{16}%<%t10%p1%{8}%-%d%e48;5;%p1%d%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 8); # %{8}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 16); # %{16}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
              pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
    $rc .= chr(48); # 0
    push(@iparam, $param[0]); # %p1
    push(@iparam, 8); # %{8}
    { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  }
  else { # %e
    $rc .= chr(52); # 4
    $rc .= chr(56); # 8
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EG0\\EH\\003' => '
#
# Stub version of: \\EG0\\EH\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '\\034C%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\034C%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(28); # \\034
  $rc .= chr(67); # C
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[3r' => '
#
# Stub version of: \\E[3r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(114); # r

  return $rc;
}
',
          '%i\\E[%p1%2d;%p2%2dr' => '
#
# Stub version of: %i\\E[%p1%2d;%p2%2dr
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  map {$param[$_]++} (0..$#param); # %i
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\233H\\233J' => '
#
# Stub version of: \\233H\\233J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(72); # H
  $rc .= chr(155); # \\233
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\037$<2>' => '
#
# Stub version of: \\037$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\002$<3*>' => '
#
# Stub version of: \\E\\002$<3*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(2); # \\002
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\347' => '
#
# Stub version of: \\377\\347
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(231); # \\347

  return $rc;
}
',
          '\\035lef %p1%d;' => '
#
# Stub version of: \\035lef %p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(102); # f
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[15;5~' => '
#
# Stub version of: \\E[15;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\233H\\2332J' => '
#
# Stub version of: \\233H\\2332J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(72); # H
  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\EC\\Eu\\E\'\\E(\\El\\EA\\E%\\E{\\E.2\\EG0\\Ed\\En' => '
#
# Stub version of: \\EC\\Eu\\E\'\\E(\\El\\EA\\E%\\E{\\E.2\\EG0\\Ed\\En
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(123); # {
  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(27); # \\E
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\E[0K$<13>' => '
#
# Stub version of: \\E[0K$<13>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E_A\\E\\\\' => '
#
# Stub version of: \\E_A\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\0=' => '
#
# Stub version of: \\0=
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(61); # =

  return $rc;
}
',
          '\\233012z' => '
#
# Stub version of: \\233012z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[5;2~' => '
#
# Stub version of: \\E[5;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[=7;<4m' => '
#
# Stub version of: \\E[=7;<4m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\377\\332' => '
#
# Stub version of: \\377\\332
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(218); # \\332

  return $rc;
}
',
          '\\E[%p1%{30}%+%cm' => '
#
# Stub version of: \\E[%p1%{30}%+%cm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  push(@iparam, 30); # %{30}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[7;42m' => '
#
# Stub version of: \\E[7;42m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[63;1"p\\E[2h' => '
#
# Stub version of: \\E[63;1"p\\E[2h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(34); # "
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[1B' => '
#
# Stub version of: \\E[1B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\030%p1%c%p2%c' => '
#
# Stub version of: \\030%p1%c%p2%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(24); # \\030
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '~^\\' => '
#
# Stub version of: ~^\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(94); # ^
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E<\\E[1;24r\\E[24;1H\\E[?7h\\E[>2;4h\\E[>1;3;5;6;7;8;9l\\E[m\\E[11m' => '
#
# Stub version of: \\E<\\E[1;24r\\E[24;1H\\E[?7h\\E[>2;4h\\E[>1;3;5;6;7;8;9l\\E[m\\E[11m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\233206z' => '
#
# Stub version of: \\233206z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EE$<270>' => '
#
# Stub version of: \\EE$<270>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^8' => '
#
# Stub version of: ^^8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\EU"' => '
#
# Stub version of: \\EU"
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(34); # "

  return $rc;
}
',
          '\\EY\\s\\s' => '
#
# Stub version of: \\EY\\s\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(32); # \\s
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\037@%p1%{65}%+%c' => '
#
# Stub version of: \\037@%p1%{65}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(64); # @
  push(@iparam, $param[0]); # %p1
  push(@iparam, 65); # %{65}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\377\\225' => '
#
# Stub version of: \\377\\225
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(149); # \\225

  return $rc;
}
',
          '\\E[H\\E[7m\\E[J$<156>' => '
#
# Stub version of: \\E[H\\E[7m\\E[J$<156>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[H\\E[J$<30>' => '
#
# Stub version of: \\E[H\\E[J$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '$<3>' => '
#
# Stub version of: $<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ER\\E0Q\\EV' => '
#
# Stub version of: \\ER\\E0Q\\EV
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(86); # V

  return $rc;
}
',
          '\\E@' => '
#
# Stub version of: \\E@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[2;6~' => '
#
# Stub version of: \\E[2;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EM$<3>' => '
#
# Stub version of: \\EM$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1;03q   f1           \\EOP\\E[2;03q   f2           \\EOQ\\E[3;03q   f3           \\EOR\\E[4;03q   f4           \\EOS\\E[5;03q   f5           \\EOT\\E[6;03q   f6           \\EOU\\E[7;03q   f7           \\EOV\\E[8;03q   f8           \\EOW' => '
#
# Stub version of: \\E[1;03q   f1           \\EOP\\E[2;03q   f2           \\EOQ\\E[3;03q   f3           \\EOR\\E[4;03q   f4           \\EOS\\E[5;03q   f5           \\EOT\\E[6;03q   f6           \\EOU\\E[7;03q   f7           \\EOV\\E[8;03q   f8           \\EOW
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(80); # P
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(50); # 2
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(51); # 3
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(82); # R
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(52); # 4
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(83); # S
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(53); # 5
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(84); # T
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(54); # 6
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(86); # V
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  $rc .= chr(56); # 8
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(87); # W

  return $rc;
}
',
          '^P^M' => '
#
# Stub version of: ^P^M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(0); # ^M

  return $rc;
}
',
          '\\Eent' => '
#
# Stub version of: \\Eent
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(110); # n
  $rc .= chr(116); # t

  return $rc;
}
',
          '^V4^W06\\017\\rVisible Bell Installed.\\016\\r\\n' => '
#
# Stub version of: ^V4^W06\\017\\rVisible Bell Installed.\\016\\r\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(52); # 4
  $rc .= chr(0); # ^W
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(15); # \\017
  $rc .= chr(13); # \\r
  $rc .= chr(86); # V
  $rc .= chr(105); # i
  $rc .= chr(115); # s
  $rc .= chr(105); # i
  $rc .= chr(98); # b
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(32); #  
  $rc .= chr(66); # B
  $rc .= chr(101); # e
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(32); #  
  $rc .= chr(73); # I
  $rc .= chr(110); # n
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(97); # a
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(101); # e
  $rc .= chr(100); # d
  $rc .= chr(46); # .
  $rc .= chr(14); # \\016
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\E[03s' => '
#
# Stub version of: \\E[03s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\377\\363' => '
#
# Stub version of: \\377\\363
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(243); # \\363

  return $rc;
}
',
          '\\E[2J\\E[?47l' => '
#
# Stub version of: \\E[2J\\E[?47l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(108); # l

  return $rc;
}
',
          '^A5\\r' => '
#
# Stub version of: ^A5\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(53); # 5
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E^_' => '
#
# Stub version of: \\E^_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^_

  return $rc;
}
',
          '\\E[H\\EJ' => '
#
# Stub version of: \\E[H\\EJ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\EFQ' => '
#
# Stub version of: \\EFQ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\EH\\EJ' => '
#
# Stub version of: \\EH\\EJ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E(\\Ek\\010\\Em\\010\\Eq' => '
#
# Stub version of: \\E(\\Ek\\010\\Em\\010\\Eq
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  $rc .= chr(109); # m
  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\233023z' => '
#
# Stub version of: \\233023z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[?7h\\E[?1h\\E[?3l\\E7\\E8' => '
#
# Stub version of: \\E[?7h\\E[?1h\\E[?3l\\E7\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\EY$<30>' => '
#
# Stub version of: \\EY$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          'Q$<\\217>' => '
#
# Stub version of: Q$<\\217>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(81); # Q
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(143); # \\217
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EeG$<150>' => '
#
# Stub version of: \\EeG$<150>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(71); # G
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^\\033\\r' => '
#
# Stub version of: ^\\033\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(27); # \\033
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EW$<19>' => '
#
# Stub version of: \\EW$<19>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(62); # >

  return $rc;
}
',
          '^O' => '
#
# Stub version of: ^O
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^O

  return $rc;
}
',
          '^\\001\\r' => '
#
# Stub version of: ^\\001\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(1); # \\001
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[>1;5B' => '
#
# Stub version of: \\E[>1;5B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\Ek\\r' => '
#
# Stub version of: \\Ek\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dH$<30>' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dH$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\010$<1>' => '
#
# Stub version of: \\010$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(8); # \\010
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ES\\Es0;\\Er0;' => '
#
# Stub version of: \\ES\\Es0;\\Er0;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\0Y' => '
#
# Stub version of: \\0Y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(89); # Y

  return $rc;
}
',
          '\\E[0%?%p1%t;2;4;5;7%;%?%p3%t;7%;%?%p2%t;2%;%?%p4%t;2;4%;%?%p5%t;5%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p1%t;2;4;5;7%;%?%p3%t;7%;%?%p2%t;2%;%?%p4%t;2;4%;%?%p5%t;5%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\r\\n$<2*/>' => '
#
# Stub version of: \\r\\n$<2*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^p' => '
#
# Stub version of: ^^p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(112); # p

  return $rc;
}
',
          '^^1' => '
#
# Stub version of: ^^1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\EOX' => '
#
# Stub version of: \\EOX
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(88); # X

  return $rc;
}
',
          '^B$\\r' => '
#
# Stub version of: ^B$\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(36); # $
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\23321~' => '
#
# Stub version of: \\23321~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[?1h\\E=$<10/>' => '
#
# Stub version of: \\E[?1h\\E=$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[2;H\\E[J' => '
#
# Stub version of: \\E[2;H\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[13;2~' => '
#
# Stub version of: \\E[13;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[1M$<9/>' => '
#
# Stub version of: \\E[1M$<9/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(57); # 9
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E<\\E>\\E[6;?2;?7;?8h\\E[4;20;?1;?3;?4;?5;?6;?18;?19l' => '
#
# Stub version of: \\E<\\E>\\E[6;?2;?7;?8h\\E[4;20;?1;?3;?4;?5;?6;?18;?19l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E7\\E[1r\\E8\\E[2;3;4;13;20;34;39;36l\\E[12;16;34h\\E[?1;3;4;5;10;18l\\E[?7;8;25h\\E>\\E[?5W\\E(B\\017\\E[4i' => '
#
# Stub version of: \\E7\\E[1r\\E8\\E[2;3;4;13;20;34;39;36l\\E[12;16;34h\\E[?1;3;4;5;10;18l\\E[?7;8;25h\\E>\\E[?5W\\E(B\\017\\E[4i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(87); # W
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\EO\\Eq\\EEK3' => '
#
# Stub version of: \\EO\\Eq\\EEK3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(75); # K
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[?25h\\E[?8c' => '
#
# Stub version of: \\E[?25h\\E[?8c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E[1;43r\\E[43;1H' => '
#
# Stub version of: \\E[1;43r\\E[43;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(51); # 3
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\23318~' => '
#
# Stub version of: \\23318~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^^Fa' => '
#
# Stub version of: ^^Fa
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(70); # F
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\E[f' => '
#
# Stub version of: \\E[f
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\E$<1>A' => '
#
# Stub version of: \\E$<1>A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[+{' => '
#
# Stub version of: \\E[+{
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(43); # +
  $rc .= chr(123); # {

  return $rc;
}
',
          '\\E[4!{' => '
#
# Stub version of: \\E[4!{
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(33); # !
  $rc .= chr(123); # {

  return $rc;
}
',
          '\\EO5C' => '
#
# Stub version of: \\EO5C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(53); # 5
  $rc .= chr(67); # C

  return $rc;
}
',
          '^\\035\\r' => '
#
# Stub version of: ^\\035\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(29); # \\035
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[[' => '
#
# Stub version of: \\E[[
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(91); # [

  return $rc;
}
',
          '\\Ed\\r' => '
#
# Stub version of: \\Ed\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(13); # \\r

  return $rc;
}
',
          'pf1' => '
#
# Stub version of: pf1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(112); # p
  $rc .= chr(102); # f
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E0@\\010\\E3\\E4\\E7' => '
#
# Stub version of: \\E0@\\010\\E3\\E4\\E7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(64); # @
  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\E[2J\\E[1;1H$<20>' => '
#
# Stub version of: \\E[2J\\E[1;1H$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '0_aaffggh jjkkllmmnnooqqssttuuvvwwxx' => '
#
# Stub version of: 0_aaffggh jjkkllmmnnooqqssttuuvvwwxx
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(48); # 0
  $rc .= chr(95); # _
  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(102); # f
  $rc .= chr(102); # f
  $rc .= chr(103); # g
  $rc .= chr(103); # g
  $rc .= chr(104); # h
  $rc .= chr(32); #  
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(110); # n
  $rc .= chr(110); # n
  $rc .= chr(111); # o
  $rc .= chr(111); # o
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(115); # s
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(118); # v
  $rc .= chr(118); # v
  $rc .= chr(119); # w
  $rc .= chr(119); # w
  $rc .= chr(120); # x
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\Ej\\EY? \\EI\\Ek' => '
#
# Stub version of: \\Ej\\EY? \\EI\\Ek
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(63); # ?
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\ESTART\\r\\E59\\,1\\r\\EEND\\r' => '
#
# Stub version of: \\ESTART\\r\\E59\\,1\\r\\EEND\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(84); # T
  $rc .= chr(65); # A
  $rc .= chr(82); # R
  $rc .= chr(84); # T
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(53); # 5
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\,
  $rc .= chr(49); # 1
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(78); # N
  $rc .= chr(68); # D
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^Y^^^N' => '
#
# Stub version of: ^Y^^^N
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^Y
  $rc .= chr(0); # ^^
  $rc .= chr(0); # ^N

  return $rc;
}
',
          '\\233@' => '
#
# Stub version of: \\233@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[5;3~' => '
#
# Stub version of: \\E[5;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          'F18' => '
#
# Stub version of: F18
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\ED' => '
#
# Stub version of: \\ED
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E`;$<150>' => '
#
# Stub version of: \\E`;$<150>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(59); # ;
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ew0' => '
#
# Stub version of: \\Ew0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\EO4R' => '
#
# Stub version of: \\EO4R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(52); # 4
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\013$<10*/>' => '
#
# Stub version of: \\013$<10*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0$}\\E[?25h\\E[2l\\E[H\\E[J' => '
#
# Stub version of: \\E[0$}\\E[?25h\\E[2l\\E[H\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(125); # }
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\020%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\020%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(16); # \\020
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '~^R' => '
#
# Stub version of: ~^R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(0); # ^R

  return $rc;
}
',
          '\\2330 p' => '
#
# Stub version of: \\2330 p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(32); #  
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E8' => '
#
# Stub version of: \\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\036FB%?%p1%t%p1%2.2X1%;%p2%p1%-%{1}%+%2.2X1%?%{23}%p2%>%t001%;\\036FX%p3%2.2X%p4%2.2X' => '
#
# Stub version of: \\036FB%?%p1%t%p1%2.2X1%;%p2%p1%-%{1}%+%2.2X1%?%{23}%p2%>%t001%;\\036FX%p3%2.2X%p4%2.2X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(66); # B
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
    $rc .= chr(49); # 1
  } # %;
  push(@iparam, $param[1]); # %p2
  push(@iparam, $param[0]); # %p1
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  push(@iparam, 1); # %{1}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  $rc .= chr(49); # 1
  if (do { # %?
           push(@iparam, 23); # %{23}
           push(@iparam, $param[1]); # %p2
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
    $rc .= chr(48); # 0
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(88); # X
  push(@iparam, $param[2]); # %p3
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  push(@iparam, $param[3]); # %p4
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X

  return $rc;
}
',
          '\\EY7\\s' => '
#
# Stub version of: \\EY7\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(55); # 7
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E[005z' => '
#
# Stub version of: \\E[005z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(122); # z

  return $rc;
}
',
          '^\\007\\r' => '
#
# Stub version of: ^\\007\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(7); # \\007
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\022$<2000>' => '
#
# Stub version of: \\022$<2000>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(18); # \\022
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[5D' => '
#
# Stub version of: \\E[5D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[%p1%i%p1%d;%p2%dH' => '
#
# Stub version of: \\E[%p1%i%p1%d;%p2%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\014$<5*>' => '
#
# Stub version of: \\014$<5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E_\\E\\\\' => '
#
# Stub version of: \\E_\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E~K$<15>' => '
#
# Stub version of: \\E~K$<15>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EH\\EM\\EY7\\s' => '
#
# Stub version of: \\EH\\EM\\EY7\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(55); # 7
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E[12;1j' => '
#
# Stub version of: \\E[12;1j
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j

  return $rc;
}
',
          '^L^K' => '
#
# Stub version of: ^L^K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^L
  $rc .= chr(0); # ^K

  return $rc;
}
',
          '\\E[24$' => '
#
# Stub version of: \\E[24$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\EG%{48}%?%p2%p6%|%t%{8}%|%;%?%p1%p3%|%p6%|%t%{4}%|%;%?%p4%t%{2}%|%;%?%p1%p5%|%t%{64}%|%;%?%p7%t%{1}%|%;%c%?%p8%t\\E)%e\\E(%;%?%p9%t\\EH\\002%e\\EH\\003%;' => '
#
# Stub version of: \\EG%{48}%?%p2%p6%|%t%{8}%|%;%?%p1%p3%|%p6%|%t%{4}%|%;%?%p4%t%{2}%|%;%?%p1%p5%|%t%{64}%|%;%?%p7%t%{1}%|%;%c%?%p8%t\\E)%e\\E(%;%?%p9%t\\EH\\002%e\\EH\\003%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  push(@iparam, 48); # %{48}
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 8); # %{8}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 64); # %{64}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  if (do { # %?
           push(@iparam, $param[7]); # %p8
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(41); # )
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(72); # H
    $rc .= chr(2); # \\002
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(72); # H
    $rc .= chr(3); # \\003
  } # %;

  return $rc;
}
',
          '\\EK$<3>' => '
#
# Stub version of: \\EK$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E=%p1%dg' => '
#
# Stub version of: \\E=%p1%dg
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(61); # =
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\E7\\E[r\\E8\\E[?5l\\E[?1l\\E>\\E[?7h\\E[?8h' => '
#
# Stub version of: \\E7\\E[r\\E8\\E[?5l\\E[?1l\\E>\\E[?7h\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '^Ni' => '
#
# Stub version of: ^Ni
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^N
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\233213z' => '
#
# Stub version of: \\233213z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\EX\\EA\\EF' => '
#
# Stub version of: \\EX\\EA\\EF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\E[031q' => '
#
# Stub version of: \\E[031q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[5l' => '
#
# Stub version of: \\E[5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[15~' => '
#
# Stub version of: \\E[15~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E7' => '
#
# Stub version of: \\E7
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\E[m\\017\\E[1;2;3;4;6l\\E[12;13;14;20l\\E[?6;97;99l\\E[?7h\\E[4i\\Ex\\E[25;1j\\212' => '
#
# Stub version of: \\E[m\\017\\E[1;2;3;4;6l\\E[12;13;14;20l\\E[?6;97;99l\\E[?7h\\E[4i\\Ex\\E[25;1j\\212
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(105); # i
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(138); # \\212

  return $rc;
}
',
          '\\E[1ZZ' => '
#
# Stub version of: \\E[1ZZ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(90); # Z
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\ENI' => '
#
# Stub version of: \\ENI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\E|%p1%{32}%+%c%p2%{32}%+%c' => '
#
# Stub version of: \\E|%p1%{32}%+%c%p2%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(124); # |
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E^Q' => '
#
# Stub version of: \\E^Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^Q

  return $rc;
}
',
          '\\017\\E(B\\E)0\\025\\E[?3l\\E[>8g' => '
#
# Stub version of: \\017\\E(B\\E)0\\025\\E[?3l\\E[>8g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(21); # \\025
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(56); # 8
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\E[>12h' => '
#
# Stub version of: \\E[>12h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E(B\\E[m' => '
#
# Stub version of: \\E(B\\E[m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\036FQ2' => '
#
# Stub version of: \\036FQ2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(81); # Q
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E[ @' => '
#
# Stub version of: \\E[ @
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(32); #  
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\E[003q' => '
#
# Stub version of: \\E[003q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\036F?9' => '
#
# Stub version of: \\036F?9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(63); # ?
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\037att e\\r' => '
#
# Stub version of: \\037att e\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(97); # a
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(32); #  
  $rc .= chr(101); # e
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[1;49r\\E[49;1H' => '
#
# Stub version of: \\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[1;49r\\E[49;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\Ei$<10/>' => '
#
# Stub version of: \\Ei$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(105); # i
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          'j$k"l!m#n)q+t\'u&v(w%x*' => '
#
# Stub version of: j$k"l!m#n)q+t\'u&v(w%x*
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(106); # j
  $rc .= chr(36); # $
  $rc .= chr(107); # k
  $rc .= chr(34); # "
  $rc .= chr(108); # l
  $rc .= chr(33); # !
  $rc .= chr(109); # m
  $rc .= chr(35); # #
  $rc .= chr(110); # n
  $rc .= chr(41); # )
  $rc .= chr(113); # q
  $rc .= chr(43); # +
  $rc .= chr(116); # t
  $rc .= chr(39); # \'
  $rc .= chr(117); # u
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(40); # (
  $rc .= chr(119); # w
  $rc .= sprintf(\'%x\', pop(@iparam)); # %x
  $rc .= chr(42); # *

  return $rc;
}
',
          '\\E[4;42m' => '
#
# Stub version of: \\E[4;42m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Ek$<2>' => '
#
# Stub version of: \\Ek$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0%?%p1%p3%|%t;7%;%?%p2%t;4%;%?%p4%t;5%;%?%p5%t;2%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p1%p3%|%t;7%;%?%p2%t;4%;%?%p4%t;5%;%?%p5%t;2%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\E[1;31;44m' => '
#
# Stub version of: \\E[1;31;44m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EU' => '
#
# Stub version of: \\EU
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U

  return $rc;
}
',
          '\\E[>51l' => '
#
# Stub version of: \\E[>51l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(53); # 5
  $rc .= chr(49); # 1
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[?7h\\E[?3h\\E[?5h' => '
#
# Stub version of: \\E[?7h\\E[?3h\\E[?5h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\Ec\\E]R' => '
#
# Stub version of: \\Ec\\E]R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\EG0\\EH\\003\\EcD' => '
#
# Stub version of: \\EG0\\EH\\003\\EcD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\EF13' => '
#
# Stub version of: \\EF13
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3

  return $rc;
}
',
          '0' => '
#
# Stub version of: 0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E_B\\E\\\\' => '
#
# Stub version of: \\E_B\\E\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(95); # _
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\E[[J' => '
#
# Stub version of: \\E[[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\017\\035\\E(B\\E)0\\E[?7h\\E[?3l\\E[>8g' => '
#
# Stub version of: \\017\\035\\E(B\\E)0\\E[?7h\\E[?3l\\E[>8g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(29); # \\035
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(56); # 8
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\ELM1 \\ELM0' => '
#
# Stub version of: \\ELM1 \\ELM0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(77); # M
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(77); # M
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[C$<5>' => '
#
# Stub version of: \\E[C$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '^^J' => '
#
# Stub version of: ^^J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\Er' => '
#
# Stub version of: \\Er
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\EFg' => '
#
# Stub version of: \\EFg
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\E[?6l' => '
#
# Stub version of: \\E[?6l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(54); # 6
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\ER$<11.5*>' => '
#
# Stub version of: \\ER$<11.5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(46); # .
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Eb?\\Ec0' => '
#
# Stub version of: \\Eb?\\Ec0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(63); # ?
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\010\\E[%i%p1%d;%p2%dH' => '
#
# Stub version of: \\010\\E[%i%p1%d;%p2%dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H

  return $rc;
}
',
          '^PR' => '
#
# Stub version of: ^PR
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\035%{775}%{108}%p1%*%{5}%/%-%Py%p2%{64}%*%{4}%+%{5}%/%Px%gy%{32}%/%{31}%&%{32}%+%c%gy%{31}%&%{96}%+%c%gx%{32}%/%{31}%&%{32}%+%c%gx%{31}%&%{64}%+%c\\037' => '
#
# Stub version of: \\035%{775}%{108}%p1%*%{5}%/%-%Py%p2%{64}%*%{4}%+%{5}%/%Px%gy%{32}%/%{31}%&%{32}%+%c%gy%{31}%&%{96}%+%c%gx%{32}%/%{31}%&%{32}%+%c%gx%{31}%&%{64}%+%c\\037
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  push(@iparam, 775); # %{775}
  push(@iparam, 108); # %{108}
  push(@iparam, $param[0]); # %p1
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 5); # %{5}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  $dynamicp->[24] = pop(@iparam); # %Py
  push(@iparam, $param[1]); # %p2
  push(@iparam, 64); # %{64}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, 4); # %{4}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  push(@iparam, 5); # %{5}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  $dynamicp->[23] = pop(@iparam); # %Px
  push(@iparam, $dynamicp->[24]); # %gy
  push(@iparam, 32); # %{32}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[24]); # %gy
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 96); # %{96}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[23]); # %gx
  push(@iparam, 32); # %{32}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $dynamicp->[23]); # %gx
  push(@iparam, 31); # %{31}
  push(@iparam, pop(@iparam) & pop(@iparam)); # %&
  push(@iparam, 64); # %{64}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(31); # \\037

  return $rc;
}
',
          '\\E<\\E F\\E>\\E[?1h\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[1;24r\\E[24;1H' => '
#
# Stub version of: \\E<\\E F\\E>\\E[?1h\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[1;24r\\E[24;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[m\\E[1;0x\\E[2;7x' => '
#
# Stub version of: \\E[m\\E[1;0x\\E[2;7x
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(120); # x
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\E[=3h\\EF1\\Ed\\EG0\\E[=5l\\E%\\El' => '
#
# Stub version of: \\E[=3h\\EF1\\Ed\\EG0\\E[=5l\\E%\\El
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EFy' => '
#
# Stub version of: \\EFy
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(121); # y

  return $rc;
}
',
          '\\E011' => '
#
# Stub version of: \\E011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1

  return $rc;
}
',
          '^B"' => '
#
# Stub version of: ^B"
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(34); # "

  return $rc;
}
',
          '\\E&d@\\E&w7f2p1I\\E&w4f1I' => '
#
# Stub version of: \\E&d@\\E&w7f2p1I\\E&w4f1I
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(55); # 7
  $rc .= chr(102); # f
  $rc .= chr(50); # 2
  $rc .= chr(112); # p
  $rc .= chr(49); # 1
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(52); # 4
  $rc .= chr(102); # f
  $rc .= chr(49); # 1
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\E]2;%p1' => '
#
# Stub version of: \\E]2;%p1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1

  return $rc;
}
',
          '\\E[19;5~' => '
#
# Stub version of: \\E[19;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EO7D' => '
#
# Stub version of: \\EO7D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(55); # 7
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\EeF$<150>\\E`;$<150>' => '
#
# Stub version of: \\EeF$<150>\\E`;$<150>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(70); # F
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(59); # ;
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0;m' => '
#
# Stub version of: \\E[0;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EM$<100>' => '
#
# Stub version of: \\EM$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^E!' => '
#
# Stub version of: ^E!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^E
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\E[?5h\\E[0q\\E[1;2q\\E[?5l\\E[0q\\E[4;3q' => '
#
# Stub version of: \\E[?5h\\E[0q\\E[1;2q\\E[?5l\\E[0q\\E[4;3q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\EOp' => '
#
# Stub version of: \\EOp
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\EK$<16/>' => '
#
# Stub version of: \\EK$<16/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[?98l\\E[?8i' => '
#
# Stub version of: \\E[?98l\\E[?8i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\EH^C' => '
#
# Stub version of: \\EH^C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(0); # ^C

  return $rc;
}
',
          '\\E[212z' => '
#
# Stub version of: \\E[212z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[%z' => '
#
# Stub version of: \\E[%z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(37); # %
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\030\\E%!0\\EKC\\E\\014\\EKR0\\EKF0\\ENM0\\ELBH=\\ETF8000010F40\\ELI100\\ELLA>\\ELM0\\EKE0\\ENF1\\EKS0\\END0\\E%!1\\Ec\\E[?3;5l\\E[?7;8h\\E[r\\E[m\\E>' => '
#
# Stub version of: \\030\\E%!0\\EKC\\E\\014\\EKR0\\EKF0\\ENM0\\ELBH=\\ETF8000010F40\\ELI100\\ELLA>\\ELM0\\EKE0\\ENF1\\EKS0\\END0\\E%!1\\Ec\\E[?3;5l\\E[?7;8h\\E[r\\E[m\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(24); # \\030
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(12); # \\014
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(82); # R
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(77); # M
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(66); # B
  $rc .= chr(72); # H
  $rc .= chr(61); # =
  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(70); # F
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(73); # I
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(76); # L
  $rc .= chr(65); # A
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(77); # M
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(69); # E
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(83); # S
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(68); # D
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E%!1\\E[1m$<2>\\E%!0' => '
#
# Stub version of: \\E%!1\\E[1m$<2>\\E%!0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\010\\ELM1_\\ELM0' => '
#
# Stub version of: \\010\\ELM1_\\ELM0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(8); # \\010
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(77); # M
  $rc .= chr(49); # 1
  $rc .= chr(95); # _
  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(77); # M
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\Ec\\E[?3h\\E[2;0y' => '
#
# Stub version of: \\Ec\\E[?3h\\E[2;0y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(121); # y

  return $rc;
}
',
          '\\EGau' => '
#
# Stub version of: \\EGau
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(97); # a
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\E[7;50m' => '
#
# Stub version of: \\E[7;50m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EH^B' => '
#
# Stub version of: \\EH^B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(0); # ^B

  return $rc;
}
',
          '\\EFD' => '
#
# Stub version of: \\EFD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E[?25h' => '
#
# Stub version of: \\E[?25h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h

  return $rc;
}
',
          '^V4^W06\\016' => '
#
# Stub version of: ^V4^W06\\016
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(52); # 4
  $rc .= chr(0); # ^W
  $rc .= chr(48); # 0
  $rc .= chr(54); # 6
  $rc .= chr(14); # \\016

  return $rc;
}
',
          '\\037com 33\\r\\n!sto 9 17 25 33 41 49 57 65 73\\r' => '
#
# Stub version of: \\037com 33\\r\\n!sto 9 17 25 33 41 49 57 65 73\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(99); # c
  $rc .= chr(111); # o
  $rc .= chr(109); # m
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(33); # !
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(111); # o
  $rc .= chr(32); #  
  $rc .= chr(57); # 9
  $rc .= chr(32); #  
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(32); #  
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(32); #  
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(32); #  
  $rc .= chr(53); # 5
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(32); #  
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E&v2S' => '
#
# Stub version of: \\E&v2S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(118); # v
  $rc .= chr(50); # 2
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E[?7h' => '
#
# Stub version of: \\E[?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\036FB%?%p1%t%p1%2.2X0%;%p2%p1%-%{1}%+%2.2X0%?%{23}%p2%>%t000%;\\036FX%p3%2.2X%p4%2.2X' => '
#
# Stub version of: \\036FB%?%p1%t%p1%2.2X0%;%p2%p1%-%{1}%+%2.2X0%?%{23}%p2%>%t000%;\\036FX%p3%2.2X%p4%2.2X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(66); # B
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
    $rc .= chr(48); # 0
  } # %;
  push(@iparam, $param[1]); # %p2
  push(@iparam, $param[0]); # %p1
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x - $y); } # %-
  push(@iparam, 1); # %{1}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, 23); # %{23}
           push(@iparam, $param[1]); # %p2
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x > $y); } # %>
           pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
    $rc .= chr(48); # 0
    $rc .= chr(48); # 0
  } # %;
  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(88); # X
  push(@iparam, $param[2]); # %p3
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  push(@iparam, $param[3]); # %p4
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X

  return $rc;
}
',
          '\\ENw' => '
#
# Stub version of: \\ENw
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(119); # w

  return $rc;
}
',
          '\\Eb%?%p1%{0}%=%t1%e%p1%{1}%=%t2%e%p1%{2}%=%t3%e%p1%{3}%=%t>%e%p1%{4}%=%t4%e%p1%{5}%=%t7%e%p1%{6}%=%t5%e%p1%{7}%=%t0%e%p1%{8}%=%t8%e%p1%{9}%=%t9%e%p1%{10}%=%t\\:%e%p1%{11}%=%t;%e%p1%{12}%=%t<%e%p1%{13}%=%t=%e%p1%{14}%=%t6%e?' => '
#
# Stub version of: \\Eb%?%p1%{0}%=%t1%e%p1%{1}%=%t2%e%p1%{2}%=%t3%e%p1%{3}%=%t>%e%p1%{4}%=%t4%e%p1%{5}%=%t7%e%p1%{6}%=%t5%e%p1%{7}%=%t0%e%p1%{8}%=%t8%e%p1%{9}%=%t9%e%p1%{10}%=%t\\:%e%p1%{11}%=%t;%e%p1%{12}%=%t<%e%p1%{13}%=%t=%e%p1%{14}%=%t6%e?
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(49); # 1
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 1); # %{1}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 2); # %{2}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(51); # 3
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 3); # %{3}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(62); # >
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 4); # %{4}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 5); # %{5}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 6); # %{6}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 7); # %{7}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 8); # %{8}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(56); # 8
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 9); # %{9}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(57); # 9
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 10); # %{10}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(128); # \\:
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 11); # %{11}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 12); # %{12}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(60); # <
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 13); # %{13}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(61); # =
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 14); # %{14}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
  }
  else { # %e
    $rc .= chr(63); # ?
  } # ,
  return $rc;
}
',
          '\\E.0\\Eg\\E}\\Ef' => '
#
# Stub version of: \\E.0\\Eg\\E}\\Ef
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(46); # .
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(125); # }
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\E[4;1m' => '
#
# Stub version of: \\E[4;1m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E~"\\EC\\Er\\E(\\EG0\\003\\E`9\\E`1' => '
#
# Stub version of: \\E~"\\EC\\Er\\E(\\EG0\\003\\E`9\\E`1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E>' => '
#
# Stub version of: \\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[5u\\027' => '
#
# Stub version of: \\E[5u\\027
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(117); # u
  $rc .= chr(23); # \\027

  return $rc;
}
',
          '\\El\\r' => '
#
# Stub version of: \\El\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%i%p1%2d;%p2%2dr' => '
#
# Stub version of: \\E[%i%p1%2d;%p2%2dr
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\030$<70>' => '
#
# Stub version of: \\030$<70>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(24); # \\030
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '+>\\,<-\\^.v0\\333`+a\\261f\\370g\\361h\\260i#j\\331k\\277l\\332m\\300n\\305o~p\\304q\\304r\\304s_t\\303u\\264v\\301w\\302x\\263y\\363z\\362{\\343|\\330}\\234~\\376' => '
#
# Stub version of: +>\\,<-\\^.v0\\333`+a\\261f\\370g\\361h\\260i#j\\331k\\277l\\332m\\300n\\305o~p\\304q\\304r\\304s_t\\303u\\264v\\301w\\302x\\263y\\363z\\362{\\343|\\330}\\234~\\376
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(62); # >
  $rc .= chr(128); # \\,
  $rc .= chr(60); # <
  $rc .= chr(45); # -
  $rc .= chr(128); # \\^
  $rc .= chr(46); # .
  $rc .= chr(118); # v
  $rc .= chr(48); # 0
  $rc .= chr(219); # \\333
  $rc .= chr(96); # `
  $rc .= chr(43); # +
  $rc .= chr(97); # a
  $rc .= chr(177); # \\261
  $rc .= chr(102); # f
  $rc .= chr(248); # \\370
  $rc .= chr(103); # g
  $rc .= chr(241); # \\361
  $rc .= chr(104); # h
  $rc .= chr(176); # \\260
  $rc .= chr(105); # i
  $rc .= chr(35); # #
  $rc .= chr(106); # j
  $rc .= chr(217); # \\331
  $rc .= chr(107); # k
  $rc .= chr(191); # \\277
  $rc .= chr(108); # l
  $rc .= chr(218); # \\332
  $rc .= chr(109); # m
  $rc .= chr(192); # \\300
  $rc .= chr(110); # n
  $rc .= chr(197); # \\305
  $rc .= chr(111); # o
  $rc .= chr(126); # ~
  $rc .= chr(112); # p
  $rc .= chr(196); # \\304
  $rc .= chr(113); # q
  $rc .= chr(196); # \\304
  $rc .= chr(114); # r
  $rc .= chr(196); # \\304
  $rc .= chr(115); # s
  $rc .= chr(95); # _
  $rc .= chr(116); # t
  $rc .= chr(195); # \\303
  $rc .= chr(117); # u
  $rc .= chr(180); # \\264
  $rc .= chr(118); # v
  $rc .= chr(193); # \\301
  $rc .= chr(119); # w
  $rc .= chr(194); # \\302
  $rc .= chr(120); # x
  $rc .= chr(179); # \\263
  $rc .= chr(121); # y
  $rc .= chr(243); # \\363
  $rc .= chr(122); # z
  $rc .= chr(242); # \\362
  $rc .= chr(123); # {
  $rc .= chr(227); # \\343
  $rc .= chr(124); # |
  $rc .= chr(216); # \\330
  $rc .= chr(125); # }
  $rc .= chr(156); # \\234
  $rc .= chr(126); # ~
  $rc .= chr(254); # \\376

  return $rc;
}
',
          '\\004$<200/>' => '
#
# Stub version of: \\004$<200/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(4); # \\004
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\233?3l' => '
#
# Stub version of: \\233?3l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[<4h' => '
#
# Stub version of: \\E[<4h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(104); # h

  return $rc;
}
',
          'f8' => '
#
# Stub version of: f8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(102); # f
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E@0\\E[?4s\\E[?4h\\E@1' => '
#
# Stub version of: \\E@0\\E[?4s\\E[?4h\\E@1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(64); # @
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(115); # s
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(64); # @
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[%?%p1%{8}%<%t%p1%{30}%+%e%p1%{82}%+%;%dm' => '
#
# Stub version of: \\E[%?%p1%{8}%<%t%p1%{30}%+%e%p1%{82}%+%;%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 8); # %{8}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x < $y); } # %<
           pop(@iparam);
         }) { # %t
    push(@iparam, $param[0]); # %p1
    push(@iparam, 30); # %{30}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    push(@iparam, 82); # %{82}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EN}' => '
#
# Stub version of: \\EN}
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(125); # }

  return $rc;
}
',
          '^Ol' => '
#
# Stub version of: ^Ol
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^O
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[>4l' => '
#
# Stub version of: \\E[>4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '^]8g @\\037' => '
#
# Stub version of: ^]8g @\\037
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^]
  $rc .= chr(56); # 8
  $rc .= chr(103); # g
  $rc .= chr(32); #  
  $rc .= chr(64); # @
  $rc .= chr(31); # \\037

  return $rc;
}
',
          '\\E[J$<150>' => '
#
# Stub version of: \\E[J$<150>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '^T' => '
#
# Stub version of: ^T
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^T

  return $rc;
}
',
          '\\036FP%p2%2.2X%p1%2.2X' => '
#
# Stub version of: \\036FP%p2%2.2X%p1%2.2X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(80); # P
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%2.2X\', pop(@iparam)); # %2.2X

  return $rc;
}
',
          '\\EDF\\EC\\Ed\\EG0\\Eg\\Er\\EO\\E\'\\E(\\E%\\Ew\\EX\\Ee \\017\\011\\Ek\\E016\\E004\\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\011\\Ex3\\0\\0\\Ex4\\r\\0\\E\\\\2\\E-07 \\011' => '
#
# Stub version of: \\EDF\\EC\\Ed\\EG0\\Eg\\Er\\EO\\E\'\\E(\\E%\\Ew\\EX\\Ee \\017\\011\\Ek\\E016\\E004\\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\011\\Ex3\\0\\0\\Ex4\\r\\0\\E\\\\2\\E-07 \\011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(32); #  
  $rc .= chr(15); # \\017
  $rc .= chr(9); # \\011
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(9); # \\011
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(52); # 4
  $rc .= chr(13); # \\r
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(45); # -
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(9); # \\011

  return $rc;
}
',
          '\\E[H\\E[2J' => '
#
# Stub version of: \\E[H\\E[2J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\2331D' => '
#
# Stub version of: \\2331D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\ER$<5*>' => '
#
# Stub version of: \\ER$<5*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\217Q' => '
#
# Stub version of: \\217Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E[1;7B' => '
#
# Stub version of: \\E[1;7B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\037dli 50\\r' => '
#
# Stub version of: \\037dli 50\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(100); # d
  $rc .= chr(108); # l
  $rc .= chr(105); # i
  $rc .= chr(32); #  
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%i%p1%02d;%p2%03dH' => '
#
# Stub version of: \\E[%i%p1%02d;%p2%03dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%02d\', pop(@iparam)); # %02d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%03d\', pop(@iparam)); # %03d
  $rc .= chr(72); # H

  return $rc;
}
',
          '^^_' => '
#
# Stub version of: ^^_
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(95); # _

  return $rc;
}
',
          '\\E%p1%d;%p2%dt' => '
#
# Stub version of: \\E%p1%d;%p2%dt
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\037mon h\\r' => '
#
# Stub version of: \\037mon h\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(109); # m
  $rc .= chr(111); # o
  $rc .= chr(110); # n
  $rc .= chr(32); #  
  $rc .= chr(104); # h
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EsL' => '
#
# Stub version of: \\EsL
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\233311z' => '
#
# Stub version of: \\233311z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\Eg\\Ef\\011%p1%{32}%+%c' => '
#
# Stub version of: \\Eg\\Ef\\011%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(9); # \\011
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '+\\020\\,\\021-\\036.^_0\\215`\\004a\\237f\\234g\\232h\\222i\\220j\\205k\\203l\\202m\\204n\\212o\\213p\\216q\\0r\\217s\\214t\\206u\\207v\\210w\\211x\\201y\\230z\\231{\\267|\\274}L~\\225' => '
#
# Stub version of: +\\020\\,\\021-\\036.^_0\\215`\\004a\\237f\\234g\\232h\\222i\\220j\\205k\\203l\\202m\\204n\\212o\\213p\\216q\\0r\\217s\\214t\\206u\\207v\\210w\\211x\\201y\\230z\\231{\\267|\\274}L~\\225
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(16); # \\020
  $rc .= chr(128); # \\,
  $rc .= chr(17); # \\021
  $rc .= chr(45); # -
  $rc .= chr(30); # \\036
  $rc .= chr(46); # .
  $rc .= chr(0); # ^_
  $rc .= chr(48); # 0
  $rc .= chr(141); # \\215
  $rc .= chr(96); # `
  $rc .= chr(4); # \\004
  $rc .= chr(97); # a
  $rc .= chr(159); # \\237
  $rc .= chr(102); # f
  $rc .= chr(156); # \\234
  $rc .= chr(103); # g
  $rc .= chr(154); # \\232
  $rc .= chr(104); # h
  $rc .= chr(146); # \\222
  $rc .= chr(105); # i
  $rc .= chr(144); # \\220
  $rc .= chr(106); # j
  $rc .= chr(133); # \\205
  $rc .= chr(107); # k
  $rc .= chr(131); # \\203
  $rc .= chr(108); # l
  $rc .= chr(130); # \\202
  $rc .= chr(109); # m
  $rc .= chr(132); # \\204
  $rc .= chr(110); # n
  $rc .= chr(138); # \\212
  $rc .= chr(111); # o
  $rc .= chr(139); # \\213
  $rc .= chr(112); # p
  $rc .= chr(142); # \\216
  $rc .= chr(113); # q
  $rc .= chr(128); # \\0
  $rc .= chr(114); # r
  $rc .= chr(143); # \\217
  $rc .= chr(115); # s
  $rc .= chr(140); # \\214
  $rc .= chr(116); # t
  $rc .= chr(134); # \\206
  $rc .= chr(117); # u
  $rc .= chr(135); # \\207
  $rc .= chr(118); # v
  $rc .= chr(136); # \\210
  $rc .= chr(119); # w
  $rc .= chr(137); # \\211
  $rc .= chr(120); # x
  $rc .= chr(129); # \\201
  $rc .= chr(121); # y
  $rc .= chr(152); # \\230
  $rc .= chr(122); # z
  $rc .= chr(153); # \\231
  $rc .= chr(123); # {
  $rc .= chr(183); # \\267
  $rc .= chr(124); # |
  $rc .= chr(188); # \\274
  $rc .= chr(125); # }
  $rc .= chr(76); # L
  $rc .= chr(126); # ~
  $rc .= chr(149); # \\225

  return $rc;
}
',
          '\\E?b' => '
#
# Stub version of: \\E?b
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E/>2h' => '
#
# Stub version of: \\E/>2h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(50); # 2
  $rc .= chr(104); # h

  return $rc;
}
',
          'F20' => '
#
# Stub version of: F20
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E0`' => '
#
# Stub version of: \\E0`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(96); # `

  return $rc;
}
',
          '\\EOz' => '
#
# Stub version of: \\EOz
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E4^O' => '
#
# Stub version of: \\E4^O
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(0); # ^O

  return $rc;
}
',
          '\\Ea%i%p1%dR%p2%dC$<2>' => '
#
# Stub version of: \\Ea%i%p1%dR%p2%dC$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(97); # a
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(82); # R
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\'J' => '
#
# Stub version of: \\E\'J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\Es0;\\Er0;' => '
#
# Stub version of: \\Es0;\\Er0;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[1;50r\\E[50;1H' => '
#
# Stub version of: \\E[1;50r\\E[50;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\377\\357' => '
#
# Stub version of: \\377\\357
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(239); # \\357

  return $rc;
}
',
          '\\EOg' => '
#
# Stub version of: \\EOg
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\E[29\\^' => '
#
# Stub version of: \\E[29\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\E\\017$<10/>' => '
#
# Stub version of: \\E\\017$<10/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(15); # \\017
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\036%p2%{32}%+%c%p1%{32}%+%c' => '
#
# Stub version of: \\036%p2%{32}%+%c%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E&dj@\\r' => '
#
# Stub version of: \\E&dj@\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(106); # j
  $rc .= chr(64); # @
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E&a23R\\r' => '
#
# Stub version of: \\E&a23R\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(82); # R
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '^B5\\r' => '
#
# Stub version of: ^B5\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(53); # 5
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E&dB' => '
#
# Stub version of: \\E&dB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(100); # d
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E^X' => '
#
# Stub version of: \\E^X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^X

  return $rc;
}
',
          '\\E%p1%dd$<3*>' => '
#
# Stub version of: \\E%p1%dd$<3*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(100); # d
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '^]' => '
#
# Stub version of: ^]
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^]

  return $rc;
}
',
          '\\EMT1' => '
#
# Stub version of: \\EMT1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(84); # T
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\032$<1/>' => '
#
# Stub version of: \\032$<1/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(26); # \\032
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1;5C' => '
#
# Stub version of: \\E[1;5C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\037dch\\r' => '
#
# Stub version of: \\037dch\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(100); # d
  $rc .= chr(99); # c
  $rc .= chr(104); # h
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E&D$<2*/>' => '
#
# Stub version of: \\E&D$<2*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(68); # D
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\036o \\E\\EQ!\\EYP\\027' => '
#
# Stub version of: \\036o \\E\\EQ!\\EYP\\027
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(111); # o
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(80); # P
  $rc .= chr(23); # \\027

  return $rc;
}
',
          '\\014$<62>' => '
#
# Stub version of: \\014$<62>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[32\\^' => '
#
# Stub version of: \\E[32\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\E[=1;<3m' => '
#
# Stub version of: \\E[=1;<3m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\0\\213' => '
#
# Stub version of: \\0\\213
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(139); # \\213

  return $rc;
}
',
          '\\EDE' => '
#
# Stub version of: \\EDE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\Eg\\ED' => '
#
# Stub version of: \\Eg\\ED
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\Ej\\Ex5\\EY8%p1%{32}%+%c\\Eo\\Eo' => '
#
# Stub version of: \\Ej\\Ex5\\EY8%p1%{32}%+%c\\Eo\\Eo
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(53); # 5
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(56); # 8
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(27); # \\E
  $rc .= chr(111); # o
  $rc .= chr(27); # \\E
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\E[1;4R' => '
#
# Stub version of: \\E[1;4R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\233?7l\\233?1l\\E(B' => '
#
# Stub version of: \\233?7l\\233?1l\\E(B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(155); # \\233
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\017\\E[?7h\\E[0;39;49m$<2>\\E>\\E[?1l' => '
#
# Stub version of: \\017\\E[?7h\\E[0;39;49m$<2>\\E>\\E[?1l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[U' => '
#
# Stub version of: \\E[U
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(85); # U

  return $rc;
}
',
          '\\E?t' => '
#
# Stub version of: \\E?t
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\EG2' => '
#
# Stub version of: \\EG2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\2330t' => '
#
# Stub version of: \\2330t
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\E[92;76"p' => '
#
# Stub version of: \\E[92;76"p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(54); # 6
  $rc .= chr(34); # "
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\ER\\r' => '
#
# Stub version of: \\ER\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EL' => '
#
# Stub version of: \\EL
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\E\'\\E(\\E\\^3\\E`9\\016\\024' => '
#
# Stub version of: \\E\'\\E(\\E\\^3\\E`9\\016\\024
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(14); # \\016
  $rc .= chr(20); # \\024

  return $rc;
}
',
          '\\E%p1%d;%p2%d;' => '
#
# Stub version of: \\E%p1%d;%p2%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[?5h$<200>\\E[?5l' => '
#
# Stub version of: \\E[?5h$<200>\\E[?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[1;6P' => '
#
# Stub version of: \\E[1;6P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[32;H' => '
#
# Stub version of: \\E[32;H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(72); # H

  return $rc;
}
',
          '~^E' => '
#
# Stub version of: ~^E
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(0); # ^E

  return $rc;
}
',
          '\\E7\\E[60;0;0;60p\\E[1Q\\E[m\\E[>20;30l\\E8' => '
#
# Stub version of: \\E7\\E[60;0;0;60p\\E[1Q\\E[m\\E[>20;30l\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(81); # Q
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[22;0;0;22p' => '
#
# Stub version of: \\E[22;0;0;22p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(112); # p

  return $rc;
}
',
          '$<2>' => '
#
# Stub version of: $<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\037att s\\r' => '
#
# Stub version of: \\037att s\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(97); # a
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(32); #  
  $rc .= chr(115); # s
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[1L$<1*>' => '
#
# Stub version of: \\E[1L$<1*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E1' => '
#
# Stub version of: \\E1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\377\\264' => '
#
# Stub version of: \\377\\264
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(180); # \\264

  return $rc;
}
',
          '\\E[2z' => '
#
# Stub version of: \\E[2z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E#K' => '
#
# Stub version of: \\E#K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\Es%i%p1%d;' => '
#
# Stub version of: \\Es%i%p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E7R2\\E9P' => '
#
# Stub version of: \\E7R2\\E9P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(82); # R
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(57); # 9
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[24H' => '
#
# Stub version of: \\E[24H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\Ea$<3>' => '
#
# Stub version of: \\Ea$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(97); # a
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[2$~\\E[1$}\\E[%i%p1%d`' => '
#
# Stub version of: \\E[2$~\\E[1$}\\E[%i%p1%d`
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(126); # ~
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(125); # }
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(96); # `

  return $rc;
}
',
          '\\E[20;4l\\E[?7h\\Eb' => '
#
# Stub version of: \\E[20;4l\\E[?7h\\Eb
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\E[60;0;0;22p\\E[60;1H\\E[K' => '
#
# Stub version of: \\E[60;0;0;22p\\E[60;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\0f' => '
#
# Stub version of: \\0f
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\E[1K$<5>' => '
#
# Stub version of: \\E[1K$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EcB0\\EH\\003' => '
#
# Stub version of: \\EcB0\\EH\\003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(66); # B
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(3); # \\003

  return $rc;
}
',
          '\\E[?1;2r\\E[34h' => '
#
# Stub version of: \\E[?1;2r\\E[34h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E4B' => '
#
# Stub version of: \\E4B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[%?%p1%t2;7%;%?%p3%t7;%;%?%p4%t5;%;%?%p2%t4;%;%?%p1%p5%|%t2;%;%?%p6%t4;7;%;m\\E)%?%p9%t6\\016%e4\\017%;' => '
#
# Stub version of: \\E[%?%p1%t2;7%;%?%p3%t7;%;%?%p4%t5;%;%?%p2%t4;%;%?%p1%p5%|%t2;%;%?%p6%t4;7;%;m\\E)%?%p9%t6\\016%e4\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(54); # 6
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(52); # 4
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\EO4D' => '
#
# Stub version of: \\EO4D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(52); # 4
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\EDF\\EC\\Eb\\EG0\\Eg\\Er\\EO\\E\'\\E(\\E%\\Ew\\EX\\Ee \\017\\011\\El\\E016\\E004\\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\011\\Ex3\\0\\0\\Ex4\\r\\0' => '
#
# Stub version of: \\EDF\\EC\\Eb\\EG0\\Eg\\Er\\EO\\E\'\\E(\\E%\\Ew\\EX\\Ee \\017\\011\\El\\E016\\E004\\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\011\\Ex3\\0\\0\\Ex4\\r\\0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(32); #  
  $rc .= chr(15); # \\017
  $rc .= chr(9); # \\011
  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(9); # \\011
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(52); # 4
  $rc .= chr(13); # \\r
  $rc .= chr(128); # \\0

  return $rc;
}
',
          '^VF\\r' => '
#
# Stub version of: ^VF\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(70); # F
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E0B\\E)' => '
#
# Stub version of: \\E0B\\E)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )

  return $rc;
}
',
          '\\E[17;3~' => '
#
# Stub version of: \\E[17;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E`;$<70>' => '
#
# Stub version of: \\E`;$<70>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(59); # ;
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[2w\\E2\\r\\n' => '
#
# Stub version of: \\E[2w\\E2\\r\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\EH\\EK' => '
#
# Stub version of: \\EH\\EK
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E[1P$<7/>' => '
#
# Stub version of: \\E[1P$<7/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\030\\E2\\E<\\E[4i\\E[?4i\\E[12h\\E[2;4;20l\\E[?0;7h\\E[?1;3;6;19l\\E[r\\E[m\\E(B\\017\\E)0\\E>' => '
#
# Stub version of: \\030\\E2\\E<\\E[4i\\E[?4i\\E[12h\\E[2;4;20l\\E[?0;7h\\E[?1;3;6;19l\\E[r\\E[m\\E(B\\017\\E)0\\E>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(24); # \\030
  $rc .= chr(27); # \\E
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(105); # i
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(105); # i
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(15); # \\017
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&a%p2%dc%p1%dY$<6>' => '
#
# Stub version of: \\E&a%p2%dc%p1%dY$<6>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(99); # c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(89); # Y
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[m\\E[>14l\\E[?1;?5;20l\\E>\\E[1m\\r' => '
#
# Stub version of: \\E[m\\E[>14l\\E[?1;?5;20l\\E>\\E[1m\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(109); # m
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E)6\\016' => '
#
# Stub version of: \\E)6\\016
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(54); # 6
  $rc .= chr(14); # \\016

  return $rc;
}
',
          '\\233301z' => '
#
# Stub version of: \\233301z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[%?%gD%t2;%;%?%gU%t4;%;%?%gB%t5;%;%?%gR%t7;%;m' => '
#
# Stub version of: \\E[%?%gD%t2;%;%?%gU%t4;%;%?%gB%t5;%;%?%gR%t7;%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $staticp->[3]); # %gD
           pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[20]); # %gU
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[1]); # %gB
           pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[17]); # %gR
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E^C' => '
#
# Stub version of: \\E^C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^C

  return $rc;
}
',
          '\\E[=8F' => '
#
# Stub version of: \\E[=8F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(56); # 8
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\377\\251' => '
#
# Stub version of: \\377\\251
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(169); # \\251

  return $rc;
}
',
          '\\E[z' => '
#
# Stub version of: \\E[z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E`\\:$<150>' => '
#
# Stub version of: \\E`\\:$<150>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ERB' => '
#
# Stub version of: \\ERB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[F' => '
#
# Stub version of: \\E[F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(70); # F

  return $rc;
}
',
          '^Pi' => '
#
# Stub version of: ^Pi
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^P
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\EO5D' => '
#
# Stub version of: \\EO5D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(53); # 5
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\r\\n\\E[A\\E7\\E[60;1;0;60p\\E8' => '
#
# Stub version of: \\r\\n\\E[A\\E7\\E[60;1;0;60p\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(65); # A
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\EOq' => '
#
# Stub version of: \\EOq
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\23342~' => '
#
# Stub version of: \\23342~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EO]' => '
#
# Stub version of: \\EO]
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(93); # ]

  return $rc;
}
',
          '\\E<\\E[1;24r\\E[24;1H\\E[?7h\\E[>4h\\E[>1;2;3;5;6;7;8;9l\\E[m\\E[11m' => '
#
# Stub version of: \\E<\\E[1;24r\\E[24;1H\\E[?7h\\E[>4h\\E[>1;2;3;5;6;7;8;9l\\E[m\\E[11m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(52); # 4
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[228z' => '
#
# Stub version of: \\E[228z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\23332~' => '
#
# Stub version of: \\23332~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\ERI' => '
#
# Stub version of: \\ERI
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(73); # I

  return $rc;
}
',
          '\\E[7m' => '
#
# Stub version of: \\E[7m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\014$<20>' => '
#
# Stub version of: \\014$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[28;2~' => '
#
# Stub version of: \\E[28;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[<4l' => '
#
# Stub version of: \\E[<4l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(108); # l

  return $rc;
}
',
          '+\\020\\,\\021-\\030.^Y0\\215`\\004a\\221f\\234g\\237h\\220i\\276j\\205k\\203l\\202m\\204n\\212o~p\\0q\\0r\\0s_t\\206u\\207v\\211w\\210x\\201y\\230z\\231{\\267|\\274~\\224' => '
#
# Stub version of: +\\020\\,\\021-\\030.^Y0\\215`\\004a\\221f\\234g\\237h\\220i\\276j\\205k\\203l\\202m\\204n\\212o~p\\0q\\0r\\0s_t\\206u\\207v\\211w\\210x\\201y\\230z\\231{\\267|\\274~\\224
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(43); # +
  $rc .= chr(16); # \\020
  $rc .= chr(128); # \\,
  $rc .= chr(17); # \\021
  $rc .= chr(45); # -
  $rc .= chr(24); # \\030
  $rc .= chr(46); # .
  $rc .= chr(0); # ^Y
  $rc .= chr(48); # 0
  $rc .= chr(141); # \\215
  $rc .= chr(96); # `
  $rc .= chr(4); # \\004
  $rc .= chr(97); # a
  $rc .= chr(145); # \\221
  $rc .= chr(102); # f
  $rc .= chr(156); # \\234
  $rc .= chr(103); # g
  $rc .= chr(159); # \\237
  $rc .= chr(104); # h
  $rc .= chr(144); # \\220
  $rc .= chr(105); # i
  $rc .= chr(190); # \\276
  $rc .= chr(106); # j
  $rc .= chr(133); # \\205
  $rc .= chr(107); # k
  $rc .= chr(131); # \\203
  $rc .= chr(108); # l
  $rc .= chr(130); # \\202
  $rc .= chr(109); # m
  $rc .= chr(132); # \\204
  $rc .= chr(110); # n
  $rc .= chr(138); # \\212
  $rc .= chr(111); # o
  $rc .= chr(126); # ~
  $rc .= chr(112); # p
  $rc .= chr(128); # \\0
  $rc .= chr(113); # q
  $rc .= chr(128); # \\0
  $rc .= chr(114); # r
  $rc .= chr(128); # \\0
  $rc .= chr(115); # s
  $rc .= chr(95); # _
  $rc .= chr(116); # t
  $rc .= chr(134); # \\206
  $rc .= chr(117); # u
  $rc .= chr(135); # \\207
  $rc .= chr(118); # v
  $rc .= chr(137); # \\211
  $rc .= chr(119); # w
  $rc .= chr(136); # \\210
  $rc .= chr(120); # x
  $rc .= chr(129); # \\201
  $rc .= chr(121); # y
  $rc .= chr(152); # \\230
  $rc .= chr(122); # z
  $rc .= chr(153); # \\231
  $rc .= chr(123); # {
  $rc .= chr(183); # \\267
  $rc .= chr(124); # |
  $rc .= chr(188); # \\274
  $rc .= chr(126); # ~
  $rc .= chr(148); # \\224

  return $rc;
}
',
          '\\EQ"\\EY(\\027\\EYD\\Eo \\036' => '
#
# Stub version of: \\EQ"\\EY(\\027\\EYD\\Eo \\036
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(81); # Q
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(40); # (
  $rc .= chr(23); # \\027
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(68); # D
  $rc .= chr(27); # \\E
  $rc .= chr(111); # o
  $rc .= chr(32); #  
  $rc .= chr(30); # \\036

  return $rc;
}
',
          'REFRSH' => '
#
# Stub version of: REFRSH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(82); # R
  $rc .= chr(69); # E
  $rc .= chr(70); # F
  $rc .= chr(82); # R
  $rc .= chr(83); # S
  $rc .= chr(72); # H

  return $rc;
}
',
          '^L' => '
#
# Stub version of: ^L
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^L

  return $rc;
}
',
          '\\E[34m' => '
#
# Stub version of: \\E[34m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E4(a' => '
#
# Stub version of: \\E4(a
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  $rc .= chr(40); # (
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\Es0\\Ef\\031' => '
#
# Stub version of: \\Es0\\Ef\\031
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(25); # \\031

  return $rc;
}
',
          '\\E[%p1%dT' => '
#
# Stub version of: \\E[%p1%dT
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\E[2s' => '
#
# Stub version of: \\E[2s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\377\\217' => '
#
# Stub version of: \\377\\217
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(143); # \\217

  return $rc;
}
',
          '\\r\\E[S' => '
#
# Stub version of: \\r\\E[S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(83); # S

  return $rc;
}
',
          '\\E[<1h' => '
#
# Stub version of: \\E[<1h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E[%p1%{1}%+%dd' => '
#
# Stub version of: \\E[%p1%{1}%+%dd
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  push(@iparam, 1); # %{1}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\E[8m' => '
#
# Stub version of: \\E[8m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[2J\\E[?47l\\E8' => '
#
# Stub version of: \\E[2J\\E[?47l\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[%p1%dL$<4*>' => '
#
# Stub version of: \\E[%p1%dL$<4*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO1;6A' => '
#
# Stub version of: \\EO1;6A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\EC\\EDF\\E[0;0v\\E[8;1v\\E[=65l' => '
#
# Stub version of: \\EC\\EDF\\E[0;0v\\E[8;1v\\E[=65l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EL\\Ex$<3*/>' => '
#
# Stub version of: \\EL\\Ex$<3*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(76); # L
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0;37;44m\\E[H\\E[J' => '
#
# Stub version of: \\E[0;37;44m\\E[H\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\Eo1' => '
#
# Stub version of: \\Eo1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(111); # o
  $rc .= chr(49); # 1

  return $rc;
}
',
          '^R^C' => '
#
# Stub version of: ^R^C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^R
  $rc .= chr(0); # ^C

  return $rc;
}
',
          '\\E[0$~\\E[1$~' => '
#
# Stub version of: \\E[0$~\\E[1$~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(36); # $
  $rc .= chr(126); # ~
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(36); # $
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E4%{64}%?%p1%t%{65}%|%;%?%p2%t%{66}%|%;%?%p3%t%{65}%|%;%?%p4%t%{68}%|%;%?%p5%t%{64}%|%;%?%p6%t%{72}%|%;%?%p7%t%{80}%|%;%c%?%p9%t\\E>A%e\\E<@%;' => '
#
# Stub version of: \\E4%{64}%?%p1%t%{65}%|%;%?%p2%t%{66}%|%;%?%p3%t%{65}%|%;%?%p4%t%{68}%|%;%?%p5%t%{64}%|%;%?%p6%t%{72}%|%;%?%p7%t%{80}%|%;%c%?%p9%t\\E>A%e\\E<@%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(52); # 4
  push(@iparam, 64); # %{64}
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    push(@iparam, 65); # %{65}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    push(@iparam, 66); # %{66}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    push(@iparam, 65); # %{65}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 68); # %{68}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    push(@iparam, 64); # %{64}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    push(@iparam, 72); # %{72}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    push(@iparam, 80); # %{80}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(62); # >
    $rc .= chr(65); # A
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(60); # <
    $rc .= chr(64); # @
  } # %;

  return $rc;
}
',
          '\\E[21;6~' => '
#
# Stub version of: \\E[21;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\Ei8' => '
#
# Stub version of: \\Ei8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(105); # i
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[32%{' => '
#
# Stub version of: \\E[32%{
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(37); # %
  $rc .= chr(123); # {

  return $rc;
}
',
          '\\EO1;7A' => '
#
# Stub version of: \\EO1;7A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[0%?%p6%t;1%;%?%p1%p3%|%t;7%;m' => '
#
# Stub version of: \\E[0%?%p6%t;1%;%?%p1%p3%|%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[99m' => '
#
# Stub version of: \\E[99m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\2334~' => '
#
# Stub version of: \\2334~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[64H' => '
#
# Stub version of: \\E[64H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(52); # 4
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[34~' => '
#
# Stub version of: \\E[34~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[3l' => '
#
# Stub version of: \\E[3l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(108); # l

  return $rc;
}
',
          '^J\\Ec' => '
#
# Stub version of: ^J\\Ec
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^J
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\EG8\\EG0' => '
#
# Stub version of: \\EG8\\EG0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[023z' => '
#
# Stub version of: \\E[023z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E(\\r' => '
#
# Stub version of: \\E(\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%p1%d@$<5>' => '
#
# Stub version of: \\E[%p1%d@$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(64); # @
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\377\\253' => '
#
# Stub version of: \\377\\253
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(171); # \\253

  return $rc;
}
',
          '\\EF-' => '
#
# Stub version of: \\EF-
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(45); # -

  return $rc;
}
',
          '\\E[%p1%dD$<30>' => '
#
# Stub version of: \\E[%p1%dD$<30>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(68); # D
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E%!1\\E[7;5m$<2>\\E%!0' => '
#
# Stub version of: \\E%!1\\E[7;5m$<2>\\E%!0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[0%?%p2%t;4%;%?%p3%p1%|%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;+m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p2%t;4%;%?%p3%p1%|%t;7%;%?%p4%t;5%;%?%p5%t;2%;%?%p6%t;1%;%?%p7%t;8%;+m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[0]); # %p1
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(43); # +
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '%c%c\\r' => '
#
# Stub version of: %c%c\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\377\\350' => '
#
# Stub version of: \\377\\350
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(232); # \\350

  return $rc;
}
',
          '\\Ec%?%p1%{0}%=%t?%e%p1%{7}%=%t0%e%p1%{15}%=%t7%e%p1%{48}%+%c' => '
#
# Stub version of: \\Ec%?%p1%{0}%=%t?%e%p1%{7}%=%t0%e%p1%{15}%=%t7%e%p1%{48}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 0); # %{0}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(63); # ?
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 7); # %{7}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(48); # 0
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 15); # %{15}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    push(@iparam, 48); # %{48}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  } # ,
  return $rc;
}
',
          '^^Pc' => '
#
# Stub version of: ^^Pc
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(80); # P
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\EF\\E)' => '
#
# Stub version of: \\EF\\E)
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )

  return $rc;
}
',
          '\\Ef%p1%{32}%+%c' => '
#
# Stub version of: \\Ef%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E[17;2~' => '
#
# Stub version of: \\E[17;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\Eu\\E~4\\Ee6\\EC\\EDF\\Ec21\\Ec31\\Ec62\\Ec72\\Ee;\\016\\E\'\\EeL\\E`9\\E\\^0\\E`1\\E`4\\Ee.\\E`\\:\\Ee)\\Ew\\EwG\\Ew0\\Ee1\\EG0\\E(\\Ed/\\Ee4\\Ed*\\EO\\E`I\\Er\\Ee"\\Ec@0B\\EcD\\024' => '
#
# Stub version of: \\Eu\\E~4\\Ee6\\EC\\EDF\\Ec21\\Ec31\\Ec62\\Ec72\\Ee;\\016\\E\'\\EeL\\E`9\\E\\^0\\E`1\\E`4\\Ee.\\E`\\:\\Ee)\\Ew\\EwG\\Ew0\\Ee1\\EG0\\E(\\Ed/\\Ee4\\Ed*\\EO\\E`I\\Er\\Ee"\\Ec@0B\\EcD\\024
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(54); # 6
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(55); # 7
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(59); # ;
  $rc .= chr(14); # \\016
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(76); # L
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(128); # \\^
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(46); # .
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(128); # \\:
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(41); # )
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(64); # @
  $rc .= chr(48); # 0
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(68); # D
  $rc .= chr(20); # \\024

  return $rc;
}
',
          '\\E[0;%p1%{58}%+%d;%p2"%s"p' => '
#
# Stub version of: \\E[0;%p1%{58}%+%d;%p2"%s"p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  push(@iparam, 58); # %{58}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(34); # "
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(34); # "
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E[0M' => '
#
# Stub version of: \\E[0M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(77); # M

  return $rc;
}
',
          '\\E[;H\\E[2J' => '
#
# Stub version of: \\E[;H\\E[2J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[48;5;%p1%dm' => '
#
# Stub version of: \\E[48;5;%p1%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E<\\E[>1;2;3;4;5;6;7;8;9l\\E[m\\E[11m\\E[?7h' => '
#
# Stub version of: \\E<\\E[>1;2;3;4;5;6;7;8;9l\\E[m\\E[11m\\E[?7h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E7\\E[r\\E8\\E>\\E[?3h\\E[?4l\\E[?5l\\E[?7h\\E[?8h' => '
#
# Stub version of: \\E7\\E[r\\E8\\E>\\E[?3h\\E[?4l\\E[?5l\\E[?7h\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          'P$<\\217>' => '
#
# Stub version of: P$<\\217>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(143); # \\217
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E%!3' => '
#
# Stub version of: \\E%!3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  push(@iparam, ! pop(@iparam)); # %!
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[11;6~' => '
#
# Stub version of: \\E[11;6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[2h\\E[2l' => '
#
# Stub version of: \\E[2h\\E[2l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[0P' => '
#
# Stub version of: \\E[0P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[8$' => '
#
# Stub version of: \\E[8$
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(36); # $

  return $rc;
}
',
          '\\036RG2%p1%02X' => '
#
# Stub version of: \\036RG2%p1%02X
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(71); # G
  $rc .= chr(50); # 2
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%02X\', pop(@iparam)); # %02X

  return $rc;
}
',
          '\\E\\001\\E5' => '
#
# Stub version of: \\E\\001\\E5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\ER$<33*>' => '
#
# Stub version of: \\ER$<33*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[2~' => '
#
# Stub version of: \\E[2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\ERK' => '
#
# Stub version of: \\ERK
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(75); # K

  return $rc;
}
',
          '0cjgktlrmfn/q\\,t5u6v8w7x.' => '
#
# Stub version of: 0cjgktlrmfn/q\\,t5u6v8w7x.
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(48); # 0
  $rc .= chr(99); # c
  $rc .= chr(106); # j
  $rc .= chr(103); # g
  $rc .= chr(107); # k
  $rc .= chr(116); # t
  $rc .= chr(108); # l
  $rc .= chr(114); # r
  $rc .= chr(109); # m
  $rc .= chr(102); # f
  $rc .= chr(110); # n
  $rc .= chr(47); # /
  $rc .= chr(113); # q
  $rc .= chr(128); # \\,
  $rc .= chr(116); # t
  $rc .= chr(53); # 5
  $rc .= chr(117); # u
  $rc .= chr(54); # 6
  $rc .= chr(118); # v
  $rc .= chr(56); # 8
  $rc .= chr(119); # w
  $rc .= chr(55); # 7
  $rc .= chr(120); # x
  $rc .= chr(46); # .

  return $rc;
}
',
          '\\Ey4' => '
#
# Stub version of: \\Ey4
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(52); # 4

  return $rc;
}
',
          '\\E[3B' => '
#
# Stub version of: \\E[3B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\EJ$<3>' => '
#
# Stub version of: \\EJ$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\036RF4831A\\036RF2E31B\\036RF1D31C\\036RF3F31D' => '
#
# Stub version of: \\036RF4831A\\036RF2E31B\\036RF1D31C\\036RF3F31D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(70); # F
  $rc .= chr(52); # 4
  $rc .= chr(56); # 8
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(65); # A
  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(70); # F
  $rc .= chr(50); # 2
  $rc .= chr(69); # E
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(66); # B
  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(68); # D
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(67); # C
  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(70); # F
  $rc .= chr(51); # 3
  $rc .= chr(70); # F
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\036RG01A00FF00000000\\036RG01B00000000FF00\\036RG01C007F00000000\\036RG01D000000007F00' => '
#
# Stub version of: \\036RG01A00FF00000000\\036RG01B00000000FF00\\036RG01C007F00000000\\036RG01D000000007F00
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(65); # A
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(70); # F
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(66); # B
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(70); # F
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(67); # C
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(30); # \\036
  $rc .= chr(82); # R
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(68); # D
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E7\\E[99;%i%p1%dx' => '
#
# Stub version of: \\E7\\E[99;%i%p1%dx
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\23331~' => '
#
# Stub version of: \\23331~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^AM\\r' => '
#
# Stub version of: ^AM\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(77); # M
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[=3;%i%p1%dm' => '
#
# Stub version of: \\E[=3;%i%p1%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          'aajjkkllmmqqttuuxx' => '
#
# Stub version of: aajjkkllmmqqttuuxx
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(97); # a
  $rc .= chr(97); # a
  $rc .= chr(106); # j
  $rc .= chr(106); # j
  $rc .= chr(107); # k
  $rc .= chr(107); # k
  $rc .= chr(108); # l
  $rc .= chr(108); # l
  $rc .= chr(109); # m
  $rc .= chr(109); # m
  $rc .= chr(113); # q
  $rc .= chr(113); # q
  $rc .= chr(116); # t
  $rc .= chr(116); # t
  $rc .= chr(117); # u
  $rc .= chr(117); # u
  $rc .= chr(120); # x
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\233M' => '
#
# Stub version of: \\233M
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(77); # M

  return $rc;
}
',
          'PgUp' => '
#
# Stub version of: PgUp
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(80); # P
  $rc .= chr(103); # g
  $rc .= chr(85); # U
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\El$<2*>' => '
#
# Stub version of: \\El$<2*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E~!\\E~4$<150>' => '
#
# Stub version of: \\E~!\\E~4$<150>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(52); # 4
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1@$<7/>' => '
#
# Stub version of: \\E[1@$<7/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(64); # @
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(55); # 7
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[e' => '
#
# Stub version of: \\E[e
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\E[?5l\\E[?1l\\E>\\E[?7h\\E[?8h' => '
#
# Stub version of: \\E[?5l\\E[?1l\\E>\\E[?7h\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\011$<5>' => '
#
# Stub version of: \\011$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(9); # \\011
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '$<4>' => '
#
# Stub version of: $<4>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\035up %p1%d;' => '
#
# Stub version of: \\035up %p1%d;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(29); # \\035
  $rc .= chr(117); # u
  $rc .= chr(112); # p
  $rc .= chr(32); #  
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[1r' => '
#
# Stub version of: \\E[1r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E$H' => '
#
# Stub version of: \\E$H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(36); # $
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\23315~' => '
#
# Stub version of: \\23315~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E7\\E[255;0;0;24;80;80p\\E8\\E[J' => '
#
# Stub version of: \\E7\\E[255;0;0;24;80;80p\\E8\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\E[O' => '
#
# Stub version of: \\E[O
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(79); # O

  return $rc;
}
',
          '\\E[H\\E[J' => '
#
# Stub version of: \\E[H\\E[J
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J

  return $rc;
}
',
          '\\Ea!' => '
#
# Stub version of: \\Ea!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(97); # a
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\ER$<2*/>' => '
#
# Stub version of: \\ER$<2*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EOW' => '
#
# Stub version of: \\EOW
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\ENT' => '
#
# Stub version of: \\ENT
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(84); # T

  return $rc;
}
',
          '\\E[7;7~' => '
#
# Stub version of: \\E[7;7~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[?F' => '
#
# Stub version of: \\E[?F
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\Ev$<6*/>' => '
#
# Stub version of: \\Ev$<6*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(54); # 6
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EG0\\EH\\002' => '
#
# Stub version of: \\EG0\\EH\\002
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(2); # \\002

  return $rc;
}
',
          '\\233111z' => '
#
# Stub version of: \\233111z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\Ee6\\E~4$<100>\\E+\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`;\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<100>' => '
#
# Stub version of: \\Ee6\\E~4$<100>\\E+\\Ed/\\Ee1\\Ed*\\Er\\EO\\E`1\\E`;\\E`@\\E~!\\E"\\Ee4\\Ex@\\E`9\\Ee7$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(52); # 4
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(47); # /
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(42); # *
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(59); # ;
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(126); # ~
  $rc .= chr(33); # !
  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(55); # 7
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[1A' => '
#
# Stub version of: \\E[1A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[l' => '
#
# Stub version of: \\E[l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[%i%p1%2d;%p2%2dH' => '
#
# Stub version of: \\E[%i%p1%2d;%p2%2dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[H\\E[J$<40>' => '
#
# Stub version of: \\E[H\\E[J$<40>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E"' => '
#
# Stub version of: \\E"
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(34); # "

  return $rc;
}
',
          '\\Ei5' => '
#
# Stub version of: \\Ei5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(105); # i
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E[=7l' => '
#
# Stub version of: \\E[=7l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(55); # 7
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[7@' => '
#
# Stub version of: \\E[7@
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(64); # @

  return $rc;
}
',
          '\\EO1;5B' => '
#
# Stub version of: \\EO1;5B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\233%p1%dA' => '
#
# Stub version of: \\233%p1%dA
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\233A' => '
#
# Stub version of: \\233A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\E[M$<2*>' => '
#
# Stub version of: \\E[M$<2*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[\\\\' => '
#
# Stub version of: \\E[\\\\
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\,
  return $rc;
}
',
          '\\EO3D' => '
#
# Stub version of: \\EO3D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(51); # 3
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E#2' => '
#
# Stub version of: \\E#2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\EdP' => '
#
# Stub version of: \\EdP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\Eb$<50/>\\Ed' => '
#
# Stub version of: \\Eb$<50/>\\Ed
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d

  return $rc;
}
',
          '\\r\\n$<3>' => '
#
# Stub version of: \\r\\n$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ek\\Ey5' => '
#
# Stub version of: \\Ek\\Ey5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E&a%p2%2dc%p1%2dY' => '
#
# Stub version of: \\E&a%p2%2dc%p1%2dY
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(99); # c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(89); # Y

  return $rc;
}
',
          '\\Ew1' => '
#
# Stub version of: \\Ew1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[?98l\\E[0i' => '
#
# Stub version of: \\E[?98l\\E[0i
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(105); # i

  return $rc;
}
',
          '\\EO3S' => '
#
# Stub version of: \\EO3S
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(51); # 3
  $rc .= chr(83); # S

  return $rc;
}
',
          '$<10>' => '
#
# Stub version of: $<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[0%?%p1%t;2;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;m' => '
#
# Stub version of: \\E[0%?%p1%t;2;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EFn' => '
#
# Stub version of: \\EFn
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(110); # n

  return $rc;
}
',
          '\\E[193z' => '
#
# Stub version of: \\E[193z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[m\\E(B' => '
#
# Stub version of: \\E[m\\E(B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\E[%\'0\'%?%p1%t%\'8\'%|%;%?%p2%t%\'8\'%|%;%?%p3%t%\'4\'%|%;%?%p4%t%\'2\'%|%;%?%p7%t%\'1\'%|%;%cZZ' => '
#
# Stub version of: \\E[%\'0\'%?%p1%t%\'8\'%|%;%?%p2%t%\'8\'%|%;%?%p3%t%\'4\'%|%;%?%p4%t%\'2\'%|%;%?%p7%t%\'1\'%|%;%cZZ
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, chr(48)); # %\'0\'
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    push(@iparam, chr(56)); # %\'8\'
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    push(@iparam, chr(56)); # %\'8\'
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    push(@iparam, chr(52)); # %\'4\'
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, chr(50)); # %\'2\'
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    push(@iparam, chr(49)); # %\'1\'
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(90); # Z
  $rc .= chr(90); # Z

  return $rc;
}
',
          '\\377\\226' => '
#
# Stub version of: \\377\\226
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(150); # \\226

  return $rc;
}
',
          '\\Eins' => '
#
# Stub version of: \\Eins
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(105); # i
  $rc .= chr(110); # n
  $rc .= chr(115); # s

  return $rc;
}
',
          '^B;\\r' => '
#
# Stub version of: ^B;\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(59); # ;
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\23314~' => '
#
# Stub version of: \\23314~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\s\\ERD' => '
#
# Stub version of: \\s\\ERD
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(32); # \\s
  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E&j@\\r' => '
#
# Stub version of: \\E&j@\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(106); # j
  $rc .= chr(64); # @
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EO1;3C' => '
#
# Stub version of: \\EO1;3C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[=5l' => '
#
# Stub version of: \\E[=5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E(\\EG%{48}%?%p1%p3%O%t%{4}%+%;%?%p2%t%{8}%+%;%?%p4%t%{2}%+%;%?%p5%t%{64}%+%;%?%p7%t%{1}%+%;%c%?%p8%t\\E)%;%?%p9%t\\EcE%e\\EcD%;' => '
#
# Stub version of: \\E(\\EG%{48}%?%p1%p3%O%t%{4}%+%;%?%p2%t%{8}%+%;%?%p4%t%{2}%+%;%?%p5%t%{64}%+%;%?%p7%t%{1}%+%;%c%?%p8%t\\E)%;%?%p9%t\\EcE%e\\EcD%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  push(@iparam, 48); # %{48}
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) || pop(@iparam)); # %O
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    push(@iparam, 8); # %{8}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    push(@iparam, 64); # %{64}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  if (do { # %?
           push(@iparam, $param[7]); # %p8
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(41); # )
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(99); # c
    $rc .= chr(69); # E
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(99); # c
    $rc .= chr(68); # D
  } # %;

  return $rc;
}
',
          '\\E[0%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;m$<2>' => '
#
# Stub version of: \\E[0%?%p1%t;7%;%?%p2%t;4%;%?%p3%t;7%;%?%p4%t;5%;%?%p6%t;1%;m$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dH$<100>' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dH$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(72); # H
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ENm' => '
#
# Stub version of: \\ENm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[%i%p1%d;%p2%dt' => '
#
# Stub version of: \\E[%i%p1%d;%p2%dt
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\EM$<5>' => '
#
# Stub version of: \\EM$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ENf' => '
#
# Stub version of: \\ENf
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(102); # f

  return $rc;
}
',
          '\\E[21m' => '
#
# Stub version of: \\E[21m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E<\\E)0' => '
#
# Stub version of: \\E<\\E)0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(48); # 0

  return $rc;
}
',
          '^\\^Y' => '
#
# Stub version of: ^\\^Y
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(128); # \\^
  $rc .= chr(89); # Y

  return $rc;
}
',
          '\\E[K$<5/>' => '
#
# Stub version of: \\E[K$<5/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ev  ^A0\\001D\\Ep\\r\\n' => '
#
# Stub version of: \\Ev  ^A0\\001D\\Ep\\r\\n
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(0); # ^A
  $rc .= chr(48); # 0
  $rc .= chr(1); # \\001
  $rc .= chr(68); # D
  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n

  return $rc;
}
',
          '\\E&bn%?%gA%t\\E&dA%;%?%gB%t\\E&dB%;%?%gH%t\\E&dH%;%?%gX%t\\E&br%;%?%gY%t\\E&bg%;%?%gZ%t\\E&bb%;%?%p1%{1}%&%t\\E&bB%{1}%e%{0}%;%PW%?%p1%{2}%&%t\\E&bG%{1}%e%{0}%;%PV%?%p1%{4}%&%t\\E&bR%{1}%e%{0}%;%PU' => '
#
# Stub version of: \\E&bn%?%gA%t\\E&dA%;%?%gB%t\\E&dB%;%?%gH%t\\E&dH%;%?%gX%t\\E&br%;%?%gY%t\\E&bg%;%?%gZ%t\\E&bb%;%?%p1%{1}%&%t\\E&bB%{1}%e%{0}%;%PW%?%p1%{2}%&%t\\E&bG%{1}%e%{0}%;%PV%?%p1%{4}%&%t\\E&bR%{1}%e%{0}%;%PU
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(98); # b
  $rc .= chr(110); # n
  if (do { # %?
           push(@iparam, $staticp->[0]); # %gA
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(100); # d
    $rc .= chr(65); # A
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[1]); # %gB
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(100); # d
    $rc .= chr(66); # B
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[7]); # %gH
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(100); # d
    $rc .= chr(72); # H
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[23]); # %gX
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(98); # b
    $rc .= chr(114); # r
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[24]); # %gY
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(98); # b
    $rc .= chr(103); # g
  } # %;
  if (do { # %?
           push(@iparam, $staticp->[25]); # %gZ
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(98); # b
    $rc .= chr(98); # b
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 1); # %{1}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(98); # b
    $rc .= chr(66); # B
    push(@iparam, 1); # %{1}
  }
  else { # %e
    push(@iparam, 0); # %{0}
  } # %;
  $staticp->[22] = pop(@iparam); # %PW
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 2); # %{2}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(98); # b
    $rc .= chr(71); # G
    push(@iparam, 1); # %{1}
  }
  else { # %e
    push(@iparam, 0); # %{0}
  } # %;
  $staticp->[21] = pop(@iparam); # %PV
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 4); # %{4}
           push(@iparam, pop(@iparam) & pop(@iparam)); # %&
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(38); # &
    $rc .= chr(98); # b
    $rc .= chr(82); # R
    push(@iparam, 1); # %{1}
  }
  else { # %e
    push(@iparam, 0); # %{0}
  } # %;
  $staticp->[20] = pop(@iparam); # %PU

  return $rc;
}
',
          '\\EG0\\EcB0\\EcD$<15>' => '
#
# Stub version of: \\EG0\\EcB0\\EcD$<15>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(66); # B
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(68); # D
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E{^K' => '
#
# Stub version of: \\E{^K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(123); # {
  $rc .= chr(0); # ^K

  return $rc;
}
',
          '\\E(B\\E)B\\E>\\E F\\E[4;20l\\E[12h\\E[?1;5;6;38;42l\\E[?7;25h\\E[4i\\E[?4i\\E[m\\E[r\\E[2$~' => '
#
# Stub version of: \\E(B\\E)B\\E>\\E F\\E[4;20l\\E[12h\\E[?1;5;6;38;42l\\E[?7;25h\\E[4i\\E[?4i\\E[m\\E[r\\E[2$~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(41); # )
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(50); # 2
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(105); # i
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(105); # i
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(36); # $
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EG0\\E(\\EH\\003%{0}%PA%{0}%PC' => '
#
# Stub version of: \\EG0\\E(\\EH\\003%{0}%PA%{0}%PC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(3); # \\003
  push(@iparam, 0); # %{0}
  $staticp->[0] = pop(@iparam); # %PA
  push(@iparam, 0); # %{0}
  $staticp->[2] = pop(@iparam); # %PC

  return $rc;
}
',
          '\\E&w7f2p2I\\E&w4f2I\\r\\EK\\E&a%p1%dC' => '
#
# Stub version of: \\E&w7f2p2I\\E&w4f2I\\r\\EK\\E&a%p1%dC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(55); # 7
  $rc .= chr(102); # f
  $rc .= chr(50); # 2
  $rc .= chr(112); # p
  $rc .= chr(50); # 2
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(119); # w
  $rc .= chr(52); # 4
  $rc .= chr(102); # f
  $rc .= chr(50); # 2
  $rc .= chr(73); # I
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(75); # K
  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C

  return $rc;
}
',
          '^\\032\\r' => '
#
# Stub version of: ^\\032\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(26); # \\032
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\037com 33\\r\\n!sto 9\\,17\\,25\\,33\\,41\\,49\\,57\\,65\\,73\\r' => '
#
# Stub version of: \\037com 33\\r\\n!sto 9\\,17\\,25\\,33\\,41\\,49\\,57\\,65\\,73\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(99); # c
  $rc .= chr(111); # o
  $rc .= chr(109); # m
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(13); # \\r
  $rc .= chr(10); # \\n
  $rc .= chr(33); # !
  $rc .= chr(115); # s
  $rc .= chr(116); # t
  $rc .= chr(111); # o
  $rc .= chr(32); #  
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\,
  $rc .= chr(49); # 1
  $rc .= chr(55); # 7
  $rc .= chr(128); # \\,
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\,
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\,
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\,
  $rc .= chr(52); # 4
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\,
  $rc .= chr(53); # 5
  $rc .= chr(55); # 7
  $rc .= chr(128); # \\,
  $rc .= chr(54); # 6
  $rc .= chr(53); # 5
  $rc .= chr(128); # \\,
  $rc .= chr(55); # 7
  $rc .= chr(51); # 3
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Ep\\r' => '
#
# Stub version of: \\Ep\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EU\\Ev  8p\\Ep\\r' => '
#
# Stub version of: \\EU\\Ev  8p\\Ep\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(56); # 8
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(112); # p
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Ej\\EY@%+ \\Eo' => '
#
# Stub version of: \\Ej\\EY@%+ \\Eo
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(64); # @
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(111); # o

  return $rc;
}
',
          '\\003%{64}%?%p1%p3%|%t%{4}%+%;%?%p2%t%{16}%+%;%?%p4%t%{2}%+%;%?%p5%t%{1}%+%;%?%p7%t%{8}%+%;%c%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\003%{64}%?%p1%p3%|%t%{4}%+%;%?%p2%t%{16}%+%;%?%p4%t%{2}%+%;%?%p5%t%{1}%+%;%?%p7%t%{8}%+%;%c%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(3); # \\003
  push(@iparam, 64); # %{64}
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    push(@iparam, 16); # %{16}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    push(@iparam, 8); # %{8}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '^^g' => '
#
# Stub version of: ^^g
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(103); # g

  return $rc;
}
',
          '\\036HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH\\037' => '
#
# Stub version of: \\036HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH\\037
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(72); # H
  $rc .= chr(31); # \\037

  return $rc;
}
',
          '\\E[0%?%p1%p3%|%t;7%;m' => '
#
# Stub version of: \\E[0%?%p1%p3%|%t;7%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[1;37;46m' => '
#
# Stub version of: \\E[1;37;46m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(54); # 6
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Er$<.7*>' => '
#
# Stub version of: \\Er$<.7*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(46); # .
  $rc .= chr(55); # 7
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EG\\Ek' => '
#
# Stub version of: \\EG\\Ek
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\ENP' => '
#
# Stub version of: \\ENP
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(80); # P

  return $rc;
}
',
          '^Al' => '
#
# Stub version of: ^Al
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[0%?%p1%p5%|%t;2%;%?%p2%p6%|%t;4%;%?%p4%t;5%;%?%p3%p1%|%p6%|%t;7%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p1%p5%|%t;2%;%?%p2%p6%|%t;4%;%?%p4%t;5%;%?%p3%p1%|%p6%|%t;7%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(50); # 2
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[0]); # %p1
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '^\\\\:' => '
#
# Stub version of: ^\\\\:
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(92); # \\
  $rc .= chr(128); # \\:

  return $rc;
}
',
          '\\E!f\\r' => '
#
# Stub version of: \\E!f\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(102); # f
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[032q' => '
#
# Stub version of: \\E[032q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\2330~' => '
#
# Stub version of: \\2330~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E<\\E[1@\\E[?2h$<1>' => '
#
# Stub version of: \\E<\\E[1@\\E[?2h$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(60); # <
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(64); # @
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EG' => '
#
# Stub version of: \\EG
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G

  return $rc;
}
',
          '\\Ev' => '
#
# Stub version of: \\Ev
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\E[%i%p1%3d;%p2%3dH' => '
#
# Stub version of: \\E[%i%p1%3d;%p2%3dH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  map {$param[$_]++} (0..$#param); # %i
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%3d\', pop(@iparam)); # %3d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%3d\', pop(@iparam)); # %3d
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[35h\\E[?3l$<80>' => '
#
# Stub version of: \\E[35h\\E[?3l$<80>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[%p1%dA$<5>' => '
#
# Stub version of: \\E[%p1%dA$<5>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(65); # A
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[;H\\E[2J$<50/>' => '
#
# Stub version of: \\E[;H\\E[2J$<50/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(59); # ;
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\036W =\\036V' => '
#
# Stub version of: \\036W =\\036V
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(87); # W
  $rc .= chr(32); #  
  $rc .= chr(61); # =
  $rc .= chr(30); # \\036
  $rc .= chr(86); # V

  return $rc;
}
',
          '^^;' => '
#
# Stub version of: ^^;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(59); # ;

  return $rc;
}
',
          '\\E[1;3Q' => '
#
# Stub version of: \\E[1;3Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\E>\\E[1;3;4;5;6l\\E[?7h\\E[m\\E[r\\E[2J\\E[H' => '
#
# Stub version of: \\E>\\E[1;3;4;5;6l\\E[?7h\\E[m\\E[r\\E[2J\\E[H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[1;5P' => '
#
# Stub version of: \\E[1;5P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E&a%p1%dy%p2%dC' => '
#
# Stub version of: \\E&a%p1%dy%p2%dC
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(97); # a
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(121); # y
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[203z' => '
#
# Stub version of: \\E[203z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[026q' => '
#
# Stub version of: \\E[026q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(113); # q

  return $rc;
}
',
          '^AD\\r' => '
#
# Stub version of: ^AD\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(68); # D
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\Ef8' => '
#
# Stub version of: \\Ef8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\2330P' => '
#
# Stub version of: \\2330P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E[%p1%dD$<1>' => '
#
# Stub version of: \\E[%p1%dD$<1>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(68); # D
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[19;1j\\E[21;4j\\Eent' => '
#
# Stub version of: \\E[19;1j\\E[21;4j\\Eent
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(110); # n
  $rc .= chr(116); # t

  return $rc;
}
',
          '\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[r' => '
#
# Stub version of: \\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E#9' => '
#
# Stub version of: \\E#9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(35); # #
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\E[1K$<3>' => '
#
# Stub version of: \\E[1K$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(75); # K
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E^D\\r' => '
#
# Stub version of: \\E^D\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(0); # ^D
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\377\\202' => '
#
# Stub version of: \\377\\202
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(130); # \\202

  return $rc;
}
',
          '\\037\\EZ\\Ek' => '
#
# Stub version of: \\037\\EZ\\Ek
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(31); # \\037
  $rc .= chr(27); # \\E
  $rc .= chr(90); # Z
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\E\\ES1' => '
#
# Stub version of: \\E\\ES1
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(49); # 1

  return $rc;
}
',
          '\\E[?=h\\Ec' => '
#
# Stub version of: \\E[?=h\\Ec
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(61); # =
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c

  return $rc;
}
',
          '\\E[=0;12C' => '
#
# Stub version of: \\E[=0;12C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\ED\\r' => '
#
# Stub version of: \\ED\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\EPY99\\:98\\E\\\\\\E[0;98v\\E[H\\E[2;7m' => '
#
# Stub version of: \\EPY99\\:98\\E\\\\\\E[0;98v\\E[H\\E[2;7m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(89); # Y
  $rc .= chr(57); # 9
  $rc .= chr(57); # 9
  $rc .= chr(128); # \\:
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(57); # 9
  $rc .= chr(56); # 8
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E7B0\\E7F7\\E7C2\\E7R3' => '
#
# Stub version of: \\E7B0\\E7F7\\E7C2\\E7R3
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(66); # B
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(70); # F
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(67); # C
  $rc .= chr(50); # 2
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(82); # R
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[0;44m\\E[1;33m' => '
#
# Stub version of: \\E[0;44m\\E[1;33m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(52); # 4
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EE!' => '
#
# Stub version of: \\EE!
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(33); # !

  return $rc;
}
',
          '\\EO2D' => '
#
# Stub version of: \\EO2D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(50); # 2
  $rc .= chr(68); # D

  return $rc;
}
',
          '\\E]+' => '
#
# Stub version of: \\E]+
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(43); # +

  return $rc;
}
',
          '\\E"0' => '
#
# Stub version of: \\E"0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(34); # "
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[H\\E[2J$<50/>' => '
#
# Stub version of: \\E[H\\E[2J$<50/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(74); # J
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[2;3~' => '
#
# Stub version of: \\E[2;3~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^^E^]' => '
#
# Stub version of: ^^E^]
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(69); # E
  $rc .= chr(0); # ^]

  return $rc;
}
',
          '\\E]0;\\007' => '
#
# Stub version of: \\E]0;\\007
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(93); # ]
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(7); # \\007

  return $rc;
}
',
          '^Ou' => '
#
# Stub version of: ^Ou
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^O
  $rc .= chr(117); # u

  return $rc;
}
',
          '^^0' => '
#
# Stub version of: ^^0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\Ej\\EY@ \\EI\\Ek' => '
#
# Stub version of: \\Ej\\EY@ \\EI\\Ek
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  $rc .= chr(64); # @
  $rc .= chr(32); #  
  $rc .= chr(27); # \\E
  $rc .= chr(73); # I
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k

  return $rc;
}
',
          '\\E[24;0;0;24p' => '
#
# Stub version of: \\E[24;0;0;24p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(112); # p

  return $rc;
}
',
          '^^q' => '
#
# Stub version of: ^^q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E[?0;0r\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h' => '
#
# Stub version of: \\E[?0;0r\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\036Fz2' => '
#
# Stub version of: \\036Fz2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(30); # \\036
  $rc .= chr(70); # F
  $rc .= chr(122); # z
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\2334%p1%dm' => '
#
# Stub version of: \\2334%p1%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(52); # 4
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[205z' => '
#
# Stub version of: \\E[205z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\Ej' => '
#
# Stub version of: \\Ej
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j

  return $rc;
}
',
          '^B#' => '
#
# Stub version of: ^B#
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(35); # #

  return $rc;
}
',
          '\\ENb' => '
#
# Stub version of: \\ENb
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\377\\362' => '
#
# Stub version of: \\377\\362
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(242); # \\362

  return $rc;
}
',
          '^^&' => '
#
# Stub version of: ^^&
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(38); # &

  return $rc;
}
',
          '\\EG0' => '
#
# Stub version of: \\EG0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[004q' => '
#
# Stub version of: \\E[004q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E7\\E[60;0;0;26p\\E8' => '
#
# Stub version of: \\E7\\E[60;0;0;26p\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(54); # 6
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\EOL' => '
#
# Stub version of: \\EOL
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(76); # L

  return $rc;
}
',
          '\\E[34\\^' => '
#
# Stub version of: \\E[34\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(52); # 4
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '^VD\\r' => '
#
# Stub version of: ^VD\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^V
  $rc .= chr(68); # D
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E!\\0\\EW  7o\\Egf\\Eb0\\Ec7\\ES7\\s' => '
#
# Stub version of: \\E!\\0\\EW  7o\\Egf\\Eb0\\Ec7\\ES7\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(55); # 7
  $rc .= chr(111); # o
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(102); # f
  $rc .= chr(27); # \\E
  $rc .= chr(98); # b
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(99); # c
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(55); # 7
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '^AL\\r' => '
#
# Stub version of: ^AL\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^A
  $rc .= chr(76); # L
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[1;3H' => '
#
# Stub version of: \\E[1;3H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\0K' => '
#
# Stub version of: \\0K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\E[4;m' => '
#
# Stub version of: \\E[4;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(109); # m

  return $rc;
}
',
          '^\\052\\r' => '
#
# Stub version of: ^\\052\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(42); # \\052
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[C' => '
#
# Stub version of: \\E[C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\217A' => '
#
# Stub version of: \\217A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(143); # \\217
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\034%p2%{32}%+%c%p1%{32}%+%c' => '
#
# Stub version of: \\034%p2%{32}%+%c%p1%{32}%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(28); # \\034
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E7\\E[0;0H\\E[M\\E8' => '
#
# Stub version of: \\E7\\E[0;0H\\E[M\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[4;7;50m' => '
#
# Stub version of: \\E[4;7;50m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '250\\E[?11l\\E[50;1|' => '
#
# Stub version of: 250\\E[?11l\\E[50;1|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\E[0%?%p1%p6%O%t;1%;%?%p2%t;4%;%?%p4%t;5%;%?%p1%p3%O%t;7%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[0%?%p1%p6%O%t;1%;%?%p2%t;4%;%?%p4%t;5%;%?%p1%p3%O%t;7%;%?%p7%t;8%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) || pop(@iparam)); # %O
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) || pop(@iparam)); # %O
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\013$<3>' => '
#
# Stub version of: \\013$<3>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(11); # \\013
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(51); # 3
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\ET$<1.0*>' => '
#
# Stub version of: \\ET$<1.0*>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(84); # T
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(46); # .
  $rc .= chr(48); # 0
  $rc .= chr(42); # *
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EY%p1%{32}%+%c%p2%{32}%+%c$<1*/>' => '
#
# Stub version of: \\EY%p1%{32}%+%c%p2%{32}%+%c$<1*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(89); # Y
  push(@iparam, $param[0]); # %p1
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  push(@iparam, 32); # %{32}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[7m$<2/>' => '
#
# Stub version of: \\E[7m$<2/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EDF\\EC\\Ed\\EG0\\Eg\\Er\\EO\\E\'\\E(\\E%\\Ew\\EX\\Ee \\017\\011\\Ek\\E016\\E004\\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\011\\Ex3\\0\\0\\Ex4\\r\\0\\E\\\\3\\E-07 \\011' => '
#
# Stub version of: \\EDF\\EC\\Ed\\EG0\\Eg\\Er\\EO\\E\'\\E(\\E%\\Ew\\EX\\Ee \\017\\011\\Ek\\E016\\E004\\Ex0\\0\\0\\Ex1\\0\\0\\Ex2\\0\\0\\011\\Ex3\\0\\0\\Ex4\\r\\0\\E\\\\3\\E-07 \\011
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(68); # D
  $rc .= chr(70); # F
  $rc .= chr(27); # \\E
  $rc .= chr(67); # C
  $rc .= chr(27); # \\E
  $rc .= chr(100); # d
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(48); # 0
  $rc .= chr(27); # \\E
  $rc .= chr(103); # g
  $rc .= chr(27); # \\E
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(27); # \\E
  $rc .= chr(39); # \'
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(27); # \\E
  $rc .= chr(37); # %
  $rc .= chr(27); # \\E
  $rc .= chr(119); # w
  $rc .= chr(27); # \\E
  $rc .= chr(88); # X
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e
  $rc .= chr(32); #  
  $rc .= chr(15); # \\017
  $rc .= chr(9); # \\011
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(52); # 4
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(48); # 0
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(50); # 2
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(9); # \\011
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\0
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(120); # x
  $rc .= chr(52); # 4
  $rc .= chr(13); # \\r
  $rc .= chr(128); # \\0
  $rc .= chr(27); # \\E
  $rc .= chr(92); # \\
  $rc .= chr(92); # \\
  $rc .= chr(51); # 3
  $rc .= chr(27); # \\E
  $rc .= chr(45); # -
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(32); #  
  $rc .= chr(9); # \\011

  return $rc;
}
',
          '\\EsR\\EsU\\EF' => '
#
# Stub version of: \\EsR\\EsU\\EF
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(82); # R
  $rc .= chr(27); # \\E
  $rc .= chr(115); # s
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(70); # F

  return $rc;
}
',
          '\\Ez%p1%{63}%+%c%p2%s\\177' => '
#
# Stub version of: \\Ez%p1%{63}%+%c%p2%s\\177
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  push(@iparam, $param[0]); # %p1
  push(@iparam, 63); # %{63}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s
  $rc .= chr(127); # \\177

  return $rc;
}
',
          '\\E[1;6R' => '
#
# Stub version of: \\E[1;6R
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(54); # 6
  $rc .= chr(82); # R

  return $rc;
}
',
          '\\E[?47l\\E8' => '
#
# Stub version of: \\E[?47l\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(55); # 7
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\017$<1>W' => '
#
# Stub version of: \\017$<1>W
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(62); # >
  $rc .= chr(87); # W

  return $rc;
}
',
          '\\E[32;2~' => '
#
# Stub version of: \\E[32;2~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[1!{' => '
#
# Stub version of: \\E[1!{
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(33); # !
  $rc .= chr(123); # {

  return $rc;
}
',
          '\\E[%p1%dL' => '
#
# Stub version of: \\E[%p1%dL
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(76); # L

  return $rc;
}
',
          '^G\\Ee' => '
#
# Stub version of: ^G\\Ee
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^G
  $rc .= chr(27); # \\E
  $rc .= chr(101); # e

  return $rc;
}
',
          '\\E[9~' => '
#
# Stub version of: \\E[9~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(57); # 9
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\0B' => '
#
# Stub version of: \\0B
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(66); # B

  return $rc;
}
',
          '\\233021z' => '
#
# Stub version of: \\233021z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[37;40m' => '
#
# Stub version of: \\E[37;40m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(55); # 7
  $rc .= chr(59); # ;
  $rc .= chr(52); # 4
  $rc .= chr(48); # 0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EW$<50>' => '
#
# Stub version of: \\EW$<50>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(53); # 5
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[4;0;2;0;1;0v\\E(0' => '
#
# Stub version of: \\E[4;0;2;0;1;0v\\E(0
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(48); # 0

  return $rc;
}
',
          '\\E[033q' => '
#
# Stub version of: \\E[033q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(113); # q

  return $rc;
}
',
          '\\E1%p2%c%p1%c' => '
#
# Stub version of: \\E1%p2%c%p1%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(49); # 1
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '^B+\\r' => '
#
# Stub version of: ^B+\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(43); # +
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%{0}%?%p2%p6%|%t%{8}%|%;%?%p1%p3%|%p6%|%t%{16}%|%;%?%p4%t%{2}%|%;%?%p1%p5%|%t%{1}%|%;%?%p7%t%{4}%|%;%dp%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[%{0}%?%p2%p6%|%t%{8}%|%;%?%p1%p3%|%p6%|%t%{16}%|%;%?%p4%t%{2}%|%;%?%p1%p5%|%t%{1}%|%;%?%p7%t%{4}%|%;%dp%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, 0); # %{0}
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 8); # %{8}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           push(@iparam, $param[5]); # %p6
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 16); # %{16}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[4]); # %p5
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, pop(@iparam) | pop(@iparam)); # %|
  } # %;
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(112); # p
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '\\E[00u\\E[<>001001024132072132u\\E[01u' => '
#
# Stub version of: \\E[00u\\E[<>001001024132072132u\\E[01u
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(60); # <
  $rc .= chr(62); # >
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(50); # 2
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(50); # 2
  $rc .= chr(117); # u
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(49); # 1
  $rc .= chr(117); # u

  return $rc;
}
',
          '\\E[12;5~' => '
#
# Stub version of: \\E[12;5~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(53); # 5
  $rc .= chr(126); # ~

  return $rc;
}
',
          '^G' => '
#
# Stub version of: ^G
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^G

  return $rc;
}
',
          '\\2334h' => '
#
# Stub version of: \\2334h
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(52); # 4
  $rc .= chr(104); # h

  return $rc;
}
',
          '\\E!^D' => '
#
# Stub version of: \\E!^D
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(33); # !
  $rc .= chr(0); # ^D

  return $rc;
}
',
          '\\EMT2' => '
#
# Stub version of: \\EMT2
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(84); # T
  $rc .= chr(50); # 2

  return $rc;
}
',
          '\\E[20;0;0;20p' => '
#
# Stub version of: \\E[20;0;0;20p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\017$<2>' => '
#
# Stub version of: \\017$<2>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(15); # \\017
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(62); # >

  return $rc;
}
',
          'F19' => '
#
# Stub version of: F19
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(70); # F
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\E[%p1%{40}%+%dm' => '
#
# Stub version of: \\E[%p1%{40}%+%dm
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  push(@iparam, 40); # %{40}
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%d\', pop(@iparam)); # %d
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Eya' => '
#
# Stub version of: \\Eya
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(97); # a

  return $rc;
}
',
          '\\E[%p1%2d;%p2%2dr' => '
#
# Stub version of: \\E[%p1%2d;%p2%2dr
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%2d\', pop(@iparam)); # %2d
  $rc .= chr(114); # r

  return $rc;
}
',
          '\\E[24m' => '
#
# Stub version of: \\E[24m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\EF08' => '
#
# Stub version of: \\EF08
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(48); # 0
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\377\\230' => '
#
# Stub version of: \\377\\230
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(152); # \\230

  return $rc;
}
',
          '\\E\\014$<1000>' => '
#
# Stub version of: \\E\\014$<1000>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(12); # \\014
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\EO1;2C' => '
#
# Stub version of: \\EO1;2C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(79); # O
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\E[>\\,\\001\\001\\E[>-\\001\\001' => '
#
# Stub version of: \\E[>\\,\\001\\001\\E[>-\\001\\001
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(128); # \\,
  $rc .= chr(1); # \\001
  $rc .= chr(1); # \\001
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(45); # -
  $rc .= chr(1); # \\001
  $rc .= chr(1); # \\001

  return $rc;
}
',
          '\\E[%p1%1d;%p2%l%2.2dq   f%p1%1d           %p2%s' => '
#
# Stub version of: \\E[%p1%1d;%p2%l%2.2dq   f%p1%1d           %p2%s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%1d\', pop(@iparam)); # %1d
  $rc .= chr(59); # ;
  push(@iparam, $param[1]); # %p2
  $rc .= chr(37); # %
  $rc .= chr(108); # l
  $rc .= sprintf(\'%2.2d\', pop(@iparam)); # %2.2d
  $rc .= chr(113); # q
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(102); # f
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%1d\', pop(@iparam)); # %1d
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  $rc .= chr(32); #  
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%s\', pop(@iparam)); # %s

  return $rc;
}
',
          '^^FE' => '
#
# Stub version of: ^^FE
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^^
  $rc .= chr(70); # F
  $rc .= chr(69); # E

  return $rc;
}
',
          '\\377\\317' => '
#
# Stub version of: \\377\\317
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(207); # \\317

  return $rc;
}
',
          '\\E[18;0;0;18p' => '
#
# Stub version of: \\E[18;0;0;18p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(56); # 8
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E003' => '
#
# Stub version of: \\E003
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(51); # 3

  return $rc;
}
',
          '\\E[20l\\r' => '
#
# Stub version of: \\E[20l\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%?%p3%t7;%;%?%p4%t5;%;%?%p2%t4;%;%?%p6%t4;7;%;%?%p1%t2;7;%;%?%p5%t2;%;m%?%p9%t\\016%e\\017%;' => '
#
# Stub version of: \\E[%?%p3%t7;%;%?%p4%t5;%;%?%p2%t4;%;%?%p6%t4;7;%;%?%p1%t2;7;%;%?%p5%t2;%;m%?%p9%t\\016%e\\017%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(53); # 5
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(52); # 4
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
    $rc .= chr(59); # ;
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(50); # 2
    $rc .= chr(59); # ;
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(14); # \\016
  }
  else { # %e
    $rc .= chr(15); # \\017
  } # %;

  return $rc;
}
',
          '^B\\:\\r' => '
#
# Stub version of: ^B\\:\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(128); # \\:
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[16p' => '
#
# Stub version of: \\E[16p
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(54); # 6
  $rc .= chr(112); # p

  return $rc;
}
',
          '\\E z"\\E?\\E\\005\\EE\\Ea %+\\s' => '
#
# Stub version of: \\E z"\\E?\\E\\005\\EE\\Ea %+\\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(32); #  
  $rc .= chr(122); # z
  $rc .= chr(34); # "
  $rc .= chr(27); # \\E
  $rc .= chr(63); # ?
  $rc .= chr(27); # \\E
  $rc .= chr(5); # \\005
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(97); # a
  $rc .= chr(32); #  
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E[23m' => '
#
# Stub version of: \\E[23m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(51); # 3
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\ESTART\\r\\E61\\,1\\r\\EEND\\r' => '
#
# Stub version of: \\ESTART\\r\\E61\\,1\\r\\EEND\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(83); # S
  $rc .= chr(84); # T
  $rc .= chr(65); # A
  $rc .= chr(82); # R
  $rc .= chr(84); # T
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(54); # 6
  $rc .= chr(49); # 1
  $rc .= chr(128); # \\,
  $rc .= chr(49); # 1
  $rc .= chr(13); # \\r
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(78); # N
  $rc .= chr(68); # D
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[1;3A' => '
#
# Stub version of: \\E[1;3A
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(65); # A

  return $rc;
}
',
          '\\n$<20>' => '
#
# Stub version of: \\n$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[10~' => '
#
# Stub version of: \\E[10~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\s' => '
#
# Stub version of: \\s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(32); # \\s

  return $rc;
}
',
          '\\E[6~' => '
#
# Stub version of: \\E[6~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(54); # 6
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\E[33~' => '
#
# Stub version of: \\E[33~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\EyB' => '
#
# Stub version of: \\EyB
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(66); # B

  return $rc;
}
',
          '^B =' => '
#
# Stub version of: ^B =
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(0); # ^B
  $rc .= chr(32); #  
  $rc .= chr(61); # =

  return $rc;
}
',
          '\\Es' => '
#
# Stub version of: \\Es
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\EE$<4>' => '
#
# Stub version of: \\EE$<4>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E&p11C' => '
#
# Stub version of: \\E&p11C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(38); # &
  $rc .= chr(112); # p
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\EP$<100>' => '
#
# Stub version of: \\EP$<100>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(80); # P
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[m$<20>' => '
#
# Stub version of: \\E[m$<20>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E`8$<100/>\\E`9' => '
#
# Stub version of: \\E`8$<100/>\\E`9
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(56); # 8
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(57); # 9

  return $rc;
}
',
          '\\233205z' => '
#
# Stub version of: \\233205z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(53); # 5
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\ER$<4>' => '
#
# Stub version of: \\ER$<4>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(52); # 4
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E\\003\\E8' => '
#
# Stub version of: \\E\\003\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(3); # \\003
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\E[0t\\E[2m' => '
#
# Stub version of: \\E[0t\\E[2m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(48); # 0
  $rc .= chr(116); # t
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E[202z' => '
#
# Stub version of: \\E[202z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(50); # 2
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[76;1p\\E[255;1H\\E[K' => '
#
# Stub version of: \\E[76;1p\\E[255;1H\\E[K
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(55); # 7
  $rc .= chr(54); # 6
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(112); # p
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(53); # 5
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(75); # K

  return $rc;
}
',
          '\\ERH' => '
#
# Stub version of: \\ERH
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(82); # R
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\E[4;2v' => '
#
# Stub version of: \\E[4;2v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(118); # v

  return $rc;
}
',
          '\\E[s' => '
#
# Stub version of: \\E[s
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(115); # s

  return $rc;
}
',
          '\\E007' => '
#
# Stub version of: \\E007
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7

  return $rc;
}
',
          '\\ENx' => '
#
# Stub version of: \\ENx
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(78); # N
  $rc .= chr(120); # x

  return $rc;
}
',
          '\\E[>6l' => '
#
# Stub version of: \\E[>6l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(54); # 6
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\EW$<8>' => '
#
# Stub version of: \\EW$<8>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(87); # W
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(56); # 8
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[19;0|' => '
#
# Stub version of: \\E[19;0|
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(57); # 9
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(124); # |

  return $rc;
}
',
          '\\E>\\E[?3h\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[1;24r\\E[24;1H' => '
#
# Stub version of: \\E>\\E[?3h\\E[?4l\\E[?5l\\E[?7h\\E[?8h\\E[1;24r\\E[24;1H
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(56); # 8
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(72); # H

  return $rc;
}
',
          '\\377\\273' => '
#
# Stub version of: \\377\\273
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(187); # \\273

  return $rc;
}
',
          '~\\030$<10>' => '
#
# Stub version of: ~\\030$<10>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(126); # ~
  $rc .= chr(24); # \\030
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '%?%p1%{8}%=%t\\E%%G\\342\\227\\230\\E%%@%e%p1%{10}%=%t\\E%%G\\342\\227\\231\\E%%@%e%p1%{12}%=%t\\E%%G\\342\\231\\0\\E%%@%e%p1%{13}%=%t\\E%%G\\342\\231\\252\\E%%@%e%p1%{14}%=%t\\E%%G\\342\\231\\253\\E%%@%e%p1%{15}%=%t\\E%%G\\342\\230\\274\\E%%@%e%p1%{27}%=%t\\E%%G\\342\\206\\220\\E%%@%e%p1%{155}%=%t\\E%%G\\340\\202\\242\\E%%@%e%p1%c%;' => '
#
# Stub version of: %?%p1%{8}%=%t\\E%%G\\342\\227\\230\\E%%@%e%p1%{10}%=%t\\E%%G\\342\\227\\231\\E%%@%e%p1%{12}%=%t\\E%%G\\342\\231\\0\\E%%@%e%p1%{13}%=%t\\E%%G\\342\\231\\252\\E%%@%e%p1%{14}%=%t\\E%%G\\342\\231\\253\\E%%@%e%p1%{15}%=%t\\E%%G\\342\\230\\274\\E%%@%e%p1%{27}%=%t\\E%%G\\342\\206\\220\\E%%@%e%p1%{155}%=%t\\E%%G\\340\\202\\242\\E%%@%e%p1%c%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, 8); # %{8}
           { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(71); # G
    $rc .= chr(226); # \\342
    $rc .= chr(151); # \\227
    $rc .= chr(152); # \\230
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(64); # @
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 10); # %{10}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(71); # G
    $rc .= chr(226); # \\342
    $rc .= chr(151); # \\227
    $rc .= chr(153); # \\231
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(64); # @
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 12); # %{12}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(71); # G
    $rc .= chr(226); # \\342
    $rc .= chr(153); # \\231
    $rc .= chr(128); # \\0
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(64); # @
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 13); # %{13}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(71); # G
    $rc .= chr(226); # \\342
    $rc .= chr(153); # \\231
    $rc .= chr(170); # \\252
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(64); # @
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 14); # %{14}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(71); # G
    $rc .= chr(226); # \\342
    $rc .= chr(153); # \\231
    $rc .= chr(171); # \\253
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(64); # @
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 15); # %{15}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(71); # G
    $rc .= chr(226); # \\342
    $rc .= chr(152); # \\230
    $rc .= chr(188); # \\274
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(64); # @
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 27); # %{27}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(71); # G
    $rc .= chr(226); # \\342
    $rc .= chr(134); # \\206
    $rc .= chr(144); # \\220
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(64); # @
  }
  elsif (do { # %e
              push(@iparam, $param[0]); # %p1
              push(@iparam, 155); # %{155}
              { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $x == $y); } # %=
              pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(71); # G
    $rc .= chr(224); # \\340
    $rc .= chr(130); # \\202
    $rc .= chr(162); # \\242
    $rc .= chr(27); # \\E
    $rc .= \'%\';
    $rc .= chr(64); # @
  }
  else { # %e
    push(@iparam, $param[0]); # %p1
    $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  } # %;

  return $rc;
}
',
          '\\EE0;0;' => '
#
# Stub version of: \\EE0;0;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;

  return $rc;
}
',
          '^\\003\\r' => '
#
# Stub version of: ^\\003\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(94); # ^
  $rc .= chr(3); # \\003
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E%%\\E(%?%p5%p8%|%t\\E)%;%?%p9%t\\E$%;\\EG%{48}%?%p7%t%{1}%+%;%?%p4%t%{2}%+%;%?%p3%p1%|%t%{4}%+%;%?%p2%t%{8}%+%;%c' => '
#
# Stub version of: \\E%%\\E(%?%p5%p8%|%t\\E)%;%?%p9%t\\E$%;\\EG%{48}%?%p7%t%{1}%+%;%?%p4%t%{2}%+%;%?%p3%p1%|%t%{4}%+%;%?%p2%t%{8}%+%;%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= \'%\';
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           push(@iparam, $param[7]); # %p8
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(41); # )
  } # %;
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(36); # $
  } # %;
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  push(@iparam, 48); # %{48}
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    push(@iparam, 1); # %{1}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    push(@iparam, 2); # %{2}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           push(@iparam, $param[0]); # %p1
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    push(@iparam, 4); # %{4}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    push(@iparam, 8); # %{8}
    push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  } # %;
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\E+$<130>' => '
#
# Stub version of: \\E+$<130>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(43); # +
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(48); # 0
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\Ej\\EH\\Eq\\Ek\\Ev\\Ey1\\Ey5\\EG\\Ey8\\Ey9\\Ey>' => '
#
# Stub version of: \\Ej\\EH\\Eq\\Ek\\Ev\\Ey1\\Ey5\\EG\\Ey8\\Ey9\\Ey>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(106); # j
  $rc .= chr(27); # \\E
  $rc .= chr(72); # H
  $rc .= chr(27); # \\E
  $rc .= chr(113); # q
  $rc .= chr(27); # \\E
  $rc .= chr(107); # k
  $rc .= chr(27); # \\E
  $rc .= chr(118); # v
  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(49); # 1
  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(53); # 5
  $rc .= chr(27); # \\E
  $rc .= chr(71); # G
  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(57); # 9
  $rc .= chr(27); # \\E
  $rc .= chr(121); # y
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E[8;7~' => '
#
# Stub version of: \\E[8;7~
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(56); # 8
  $rc .= chr(59); # ;
  $rc .= chr(55); # 7
  $rc .= chr(126); # ~

  return $rc;
}
',
          '\\n$<2*/>' => '
#
# Stub version of: \\n$<2*/>
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(10); # \\n
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(42); # *
  $rc .= chr(47); # /
  $rc .= chr(62); # >

  return $rc;
}
',
          '\\E`5' => '
#
# Stub version of: \\E`5
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(96); # `
  $rc .= chr(53); # 5

  return $rc;
}
',
          '\\E[2;0v' => '
#
# Stub version of: \\E[2;0v
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(50); # 2
  $rc .= chr(59); # ;
  $rc .= chr(48); # 0
  $rc .= chr(118); # v

  return $rc;
}
',
          '!com 31\\r' => '
#
# Stub version of: !com 31\\r
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(33); # !
  $rc .= chr(99); # c
  $rc .= chr(111); # o
  $rc .= chr(109); # m
  $rc .= chr(32); #  
  $rc .= chr(51); # 3
  $rc .= chr(49); # 1
  $rc .= chr(13); # \\r

  return $rc;
}
',
          '\\E[%?%p1%t7%;%?%p2%t;4%;%?%p3%t;7%;%?%p6%t;1%;%?%p6%p4%|%t;5%;%?%p5%t;0%;m' => '
#
# Stub version of: \\E[%?%p1%t7%;%?%p2%t;4%;%?%p3%t;7%;%?%p6%t;1%;%?%p6%p4%|%t;5%;%?%p5%t;0%;m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           pop(@iparam);
         }) { # %t
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[2]); # %p3
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           push(@iparam, $param[3]); # %p4
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[4]); # %p5
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(48); # 0
  } # %;
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\E*' => '
#
# Stub version of: \\E*
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(42); # *

  return $rc;
}
',
          '\\E>\\E[m\\014' => '
#
# Stub version of: \\E>\\E[m\\014
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(12); # \\014

  return $rc;
}
',
          '\\233207z' => '
#
# Stub version of: \\233207z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(55); # 7
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\E[U\\E[?20l\\E[?7h\\E[1Q' => '
#
# Stub version of: \\E[U\\E[?20l\\E[?7h\\E[1Q
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(85); # U
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(81); # Q

  return $rc;
}
',
          '\\Eb' => '
#
# Stub version of: \\Eb
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(98); # b

  return $rc;
}
',
          '\\0P' => '
#
# Stub version of: \\0P
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(80); # P

  return $rc;
}
',
          '\\E7\\E[r\\E8\\EE\\EE\\EE\\EM\\EM\\EM\\E[?7h\\E[?1l\\E[?3l\\E7\\E[1;33r\\E8' => '
#
# Stub version of: \\E7\\E[r\\E8\\EE\\EE\\EE\\EM\\EM\\EM\\E[?7h\\E[?1l\\E[?3l\\E7\\E[1;33r\\E8
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(69); # E
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(77); # M
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(55); # 7
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(55); # 7
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(51); # 3
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(56); # 8

  return $rc;
}
',
          '\\Ez(' => '
#
# Stub version of: \\Ez(
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(122); # z
  $rc .= chr(40); # (

  return $rc;
}
',
          '\\EFV' => '
#
# Stub version of: \\EFV
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  $rc .= chr(86); # V

  return $rc;
}
',
          '\\E[1;24r\\E[?10;3l\\E[?1;25h\\E[4l\\E[m\\E(B\\E=' => '
#
# Stub version of: \\E[1;24r\\E[?10;3l\\E[?1;25h\\E[4l\\E[m\\E(B\\E=
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(52); # 4
  $rc .= chr(114); # r
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(51); # 3
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(49); # 1
  $rc .= chr(59); # ;
  $rc .= chr(50); # 2
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(52); # 4
  $rc .= chr(108); # l
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(109); # m
  $rc .= chr(27); # \\E
  $rc .= chr(40); # (
  $rc .= chr(66); # B
  $rc .= chr(27); # \\E
  $rc .= chr(61); # =

  return $rc;
}
',
          '\\E[13\\^' => '
#
# Stub version of: \\E[13\\^
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(128); # \\^

  return $rc;
}
',
          '\\016%p1%c\\020%p2%{10}%/%{16}%*%p2%{10}%m%+%c' => '
#
# Stub version of: \\016%p1%c\\020%p2%{10}%/%{16}%*%p2%{10}%m%+%c
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(14); # \\016
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c
  $rc .= chr(16); # \\020
  push(@iparam, $param[1]); # %p2
  push(@iparam, 10); # %{10}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x / $y) : 0); } # %/
  push(@iparam, 16); # %{16}
  push(@iparam, pop(@iparam) * pop(@iparam)); # %*
  push(@iparam, $param[1]); # %p2
  push(@iparam, 10); # %{10}
  { my $y = pop(@iparam); my $x = pop(@iparam); push(@iparam, $y ? int($x % $y) : 0); } # %m
  push(@iparam, pop(@iparam) + pop(@iparam)); # %+
  $rc .= sprintf(\'%c\', pop(@iparam)); # %c

  return $rc;
}
',
          '\\377\\346' => '
#
# Stub version of: \\377\\346
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(255); # \\377
  $rc .= chr(230); # \\346

  return $rc;
}
',
          '\\E[=10;12C' => '
#
# Stub version of: \\E[=10;12C
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(61); # =
  $rc .= chr(49); # 1
  $rc .= chr(48); # 0
  $rc .= chr(59); # ;
  $rc .= chr(49); # 1
  $rc .= chr(50); # 2
  $rc .= chr(67); # C

  return $rc;
}
',
          '\\EF%p2%03d%p1%03d' => '
#
# Stub version of: \\EF%p2%03d%p1%03d
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(70); # F
  push(@iparam, $param[1]); # %p2
  $rc .= sprintf(\'%03d\', pop(@iparam)); # %03d
  push(@iparam, $param[0]); # %p1
  $rc .= sprintf(\'%03d\', pop(@iparam)); # %03d

  return $rc;
}
',
          '\\E[?5h$<200/>\\E[?5l' => '
#
# Stub version of: \\E[?5h$<200/>\\E[?5l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(104); # h
  $rc .= chr(36); # $
  $rc .= chr(60); # <
  $rc .= chr(50); # 2
  $rc .= chr(48); # 0
  $rc .= chr(48); # 0
  $rc .= chr(47); # /
  $rc .= chr(62); # >
  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(63); # ?
  $rc .= chr(53); # 5
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[>13l' => '
#
# Stub version of: \\E[>13l
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(62); # >
  $rc .= chr(49); # 1
  $rc .= chr(51); # 3
  $rc .= chr(108); # l

  return $rc;
}
',
          '\\E[114z' => '
#
# Stub version of: \\E[114z
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(91); # [
  $rc .= chr(49); # 1
  $rc .= chr(49); # 1
  $rc .= chr(52); # 4
  $rc .= chr(122); # z

  return $rc;
}
',
          '\\2330%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m%?%p9%t\\E(0%e\\E(B%;' => '
#
# Stub version of: \\2330%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m%?%p9%t\\E(0%e\\E(B%;
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(155); # \\233
  $rc .= chr(48); # 0
  if (do { # %?
           push(@iparam, $param[5]); # %p6
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(49); # 1
  } # %;
  if (do { # %?
           push(@iparam, $param[1]); # %p2
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(52); # 4
  } # %;
  if (do { # %?
           push(@iparam, $param[0]); # %p1
           push(@iparam, $param[2]); # %p3
           push(@iparam, pop(@iparam) | pop(@iparam)); # %|
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(55); # 7
  } # %;
  if (do { # %?
           push(@iparam, $param[3]); # %p4
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(53); # 5
  } # %;
  if (do { # %?
           push(@iparam, $param[6]); # %p7
           pop(@iparam);
         }) { # %t
    $rc .= chr(59); # ;
    $rc .= chr(56); # 8
  } # %;
  $rc .= chr(109); # m
  if (do { # %?
           push(@iparam, $param[8]); # %p9
           pop(@iparam);
         }) { # %t
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(48); # 0
  }
  else { # %e
    $rc .= chr(27); # \\E
    $rc .= chr(40); # (
    $rc .= chr(66); # B
  } # %;

  return $rc;
}
',
          '\\0m' => '
#
# Stub version of: \\0m
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(128); # \\0
  $rc .= chr(109); # m

  return $rc;
}
',
          '\\Efind' => '
#
# Stub version of: \\Efind
#
sub {
  my ($self, $dynamicp, $staticp, @param) = @_;
  # Initialized with @param to be termcap compatible
  my @iparam = @param;
  my $rc = \'\';

  $rc .= chr(27); # \\E
  $rc .= chr(102); # f
  $rc .= chr(105); # i
  $rc .= chr(110); # n
  $rc .= chr(100); # d

  return $rc;
}
'
        };
