My wishes about NEW-RPL

[compsystems]

sorry for my bad English =[

Hi, HP-RPL users and RPN lovers, Please comment on each point exposed

I have not tried yet NEWRPL because I have not a hp50real and the NewRPL-DEMO app for windows not have a keyboard =(
these suggestions are based on what has the hp 50 and that I would like to see in newRPL or in a future firmware upgrade from HP

1: Use an operator optional as end line, semicolon (; ) for example. Where the program editor can format each sentences, and thus to adjust the code vertically, my HP48/50 programs always the editor adjusted to line the width of the screen and not as I wrote in the source code =(

Code:

«
     3 →LIST; 
     { A B C } STO; 
     B NEG B 2 ^ 4 A * C * - √ + 2 A * /;
     B NEG B 2 ^ 4 A * C * - √ - 2 A * /;
     { A B C };
     PURGE;
»
'RCUADRATIC' STO

'RCUADRATIC' RCL
->

Code:

«
     3 →LIST; 
     { A B C } STO; 
     B NEG B 2 ^ 4 A * C * - √ + 2 A * /;
     B NEG B 2 ^ 4 A * C * - √ - 2 A * /;
     { A B C };
     PURGE;
»

=)

And not

Code:

« 3 →LIST  { A B C } STO  B NEG B 2 ^ 4 A * C * - √ + 2 A * /  B NEG B 2 ^ 4 A * C * - √ - 2 A * /  { A B C }  PURGE ;
»

=(





2: Do not delete comments to store programs

Code:

«@ inicio de programa
     3 →LIST                                 @ creación de una lista con 3 objetos que deben estar en pila
     { A B C } STO                         @ (STORE) almacenamiento global paralelo
     B NEG B 2 ^ 4 A * C * - √ + 2 A * / @ cálculo de la raiz1
     B NEG B 2 ^ 4 A * C * - √ - 2 A * /  @ raiz2
     { A B C }
     PURGE
»
`RCUADRADIC` STO

'RCUADRATIC' RCL
->

Code:

«
     3 →LIST 
     { A B C } STO 
     B NEG B 2 ^ 4 A * C * - √ + 2 A * /
     B NEG B 2 ^ 4 A * C * - √ - 2 A * /
     { A B C }
     PURGE
»

=(

3: use a different delimiter between variables & symbolic expression, for example a polynomial 'x^1' -> 'x' would be treated as algebraic expression and non-variable

delimiters `` for storage

Code:

 `RCUADRADIC` STO

delimiters '' for algebraic expression

Code:

 'X' STO

Code:

'X^1' EVAL TYPE @ returns  6
'X^2' EVAL TYPE @ returns 9

should return the same data type (9), the solution to the ambiguity of a variable as algrebaica expression is solved with my idea

Code:


 'X' EVAL 'X'TYPE @ returns  6
`X^1` EVAL `X` TYPE @ returns  9
`X^2` EVAL `X^2` TYPE @  returns 9

Hold right key (hp50)+ [''], put the backtick or reverse quotes

4: use "ENDIF" "ENDCASE" "ENDWHILE" "ENDDO" ETC as option to visually and detect the body block, also this allows easier code converters

The following code is very difficult to know which end is up to each block when no indentation

Code:

IF
THEN
CASE
THEN
END
THEN
END
END
WHILE
REPEAT
DO
UNTIL
END
END
END

->

Code:

IF
THEN
CASE
THEN
ENDCASE
THEN
ENDCASE
ENDCASEBLOCK
WHILE
REPEAT
DO
UNTIL
ENDDO
ENDWHILE
ENDIF

5: A flag to maintain always a complex number in format (x, y) dupla

(x, y) [ENTER] (x, y) and not x+y*i and not (r, angle theta)



6: a new type of data is needed tripla (x,y,z) for geometric objects



7: Local storage in RPN

Code:

«
  `A` `B` `C` →
  «
     ...
  »
»

==
1 2 3 `A` `B` `C` → @ RPN NOTATION =)

Code:

«
  → A B C 
  «
     ...
  »
»

==
1 2 3 → A B C @ infix notation =(

[compsystems]

8: Please add the PART function, built-in the system, this function is essential in the handling of algebraic expression

thread
http://www.hpmuseum.org/forum/thread-637...light=part

Code:

« 0 0 { } -> EXPRESSION XPART NPARTS OPERATOR OBJECTS
  « EXPRESSION EVAL
    IFERR OBJ->
    THEN ->STR 'OPERATOR' STO 0 'NPARTS' STO OPERATOR 1 ->LIST 'OBJECTS' STO
    ELSE ->STR 'OPERATOR' STO 'NPARTS' STO NPARTS ->LIST 'OBJECTS' STO NPARTS OPERATOR OBJECTS 3 ->LIST DROP
      IF XPART NPARTS <= NOT
      THEN "EXPRESSION " EXPRESSION + " CONTAINS ONLY " + NPARTS + " PARTS" + KILL
      END
      IF XPART 0 ==
      THEN OPERATOR
      ELSE
        IF XPART -1 ==
        THEN NPARTS
        ELSE OBJECTS XPART GET
        END
      END
    END
  »
»
'PART' STO

'sin(x)+cos(x))' -1 → 2 // 2 parts
'sin(x)+cos(x)' 0 → "+" // operator
'sin(x)+cos(x)' 1 → 'sin(x)' // part1
'sin(x)+cos(x)' 2 → 'cos(x)' // part2
'sin(x)+cos(x)' 3 → "nonexistent part in the expression"

[Guenter Schink]

Answer refers to the numbers in your first post

1. Sounds interesting

2. is already available:
a: @this a volatile comment @
b: @@this is a persistent comment@@

4. I'd support that

7. is already available, different syntax though: <<1 'A' LSTO 2 'B' LSTO 3 'C' LSTO>> This creates local variables anywhere as you see fit, and these are much faster accessible with LRCL than global variables with RCL.

Günter

[Claudio L.]

(09-30-2016 03:16 AM)compsystems Wrote:  1: Use an operator optional as end line, semicolon (; ) for example.

Persistent comments also preserve the newline at the end. This means all you have to do to keep it formatted is add a comment at the end:

Code:


<< @@ This is a persistent comment, which also can be empty as in the next line
DUP @@
>>

(09-30-2016 03:16 AM)compsystems Wrote:  2: Do not delete comments to store programs

Already explained by Guenter, just use @@ for single line permanent comment.

(09-30-2016 03:16 AM)compsystems Wrote:  3: use a different delimiter between variables & symbolic expression, for example a polynomial 'x^1' -> 'x' would be treated as algebraic expression and non-variable

It would break compatibility too much.

(09-30-2016 03:16 AM)compsystems Wrote:  4: use "ENDIF" "ENDCASE" "ENDWHILE" "ENDDO" ETC as option to visually and detect the body block, also this allows easier code converters

This already exists. You can code using ENDIF, ENDCASE, ENDWHILE, ENDDO, and you can also distinguish THEN, THENERR and THENCASE. The code can decompile to either END or all different forms of end. Right now it's set to END and THEN, so even if you code with ENDIF, it will display END when you decompile it. Back when I did this I didn't have flags implemented yet, and then I forgot all about it. I need to find a flag to configure this option.
The accepted constructs are:

Code:


IF ... THEN ... ELSE ... ENDIF

IFERR ... THENERR ... ELSEERR ... ENDERR

CASE
... THENCASE ... ENDTHEN
...[default]
ENDCASE

DO ... UNTIL ... ENDDO

WHILE ... REPEAT ... ENDWHILE

(09-30-2016 03:16 AM)compsystems Wrote:  5: A flag to maintain always a complex number in format (x, y) dupla

(x, y) [ENTER] (x, y) and not x+y*i and not (r, angle theta)

This already exists, without any flags. A number stays the way you entered unless you explicitly convert it to other form.

(09-30-2016 03:16 AM)compsystems Wrote:  6: a new type of data is needed tripla (x,y,z) for geometric objects

??? Please explain better, I don't understand why you would need a separate type, you can use vectors for that.
Complex numbers are not vectors because i^2=-1, (being 'i' considered as the unit vector for the second component of the dupla). This is inconsistent with a standard vector space, hence it needs different rules than a vector. All other nth-uplas are the same.

(09-30-2016 03:16 AM)compsystems Wrote:  7: Local storage in RPN

This also already exists.

[compsystems]

(09-30-2016 03:16 AM)compsystems Wrote:  1: Use an operator optional as end line, semicolon (; ) for example.

Persistent comments also preserve the newline at the end. This means all you have to do to keep it formatted is add a comment at the end:

Code:


<< @@ This is a persistent comment, which also can be empty as in the next line
DUP @@
>>

> but if the source code has no comments, the formatting is lost, it is necessary to finalize the "sentences" somehow, the semicolon is best

(09-30-2016 03:16 AM)compsystems Wrote:  2: Do not delete comments to store programs

Already explained by Guenter, just use @@ for single line permanent comment.

>OK

(09-30-2016 03:16 AM)compsystems Wrote:  3: use a different delimiter between variables & symbolic expression, for example a polynomial 'x^1' -> 'x' would be treated as algebraic expression and non-variable

It would break compatibility too much.

>partly yes, but this is a serious in handling algebraic expressions problem, create patches within the code to avoid ambiguity. the idea is to work more naturally, separating variables of algebraic expressions

the hp49/hp50 if include this new delimiter, but it is useless because it changes the delimiters try
`X^1` EVAL returns 'X'

(09-30-2016 03:16 AM)compsystems Wrote:  4: use "ENDIF" "ENDCASE" "ENDWHILE" "ENDDO" ETC as option to visually and detect the body block, also this allows easier code converters

This already exists. You can code using ENDIF, ENDCASE, ENDWHILE, ENDDO, and you can also distinguish THEN, THENERR and THENCASE. The code can decompile to either END or all different forms of end. Right now it's set to END and THEN, so even if you code with ENDIF, it will display END when you decompile it. Back when I did this I didn't have flags implemented yet, and then I forgot all about it. I need to find a flag to configure this option.
The accepted constructs are:

Code:


IF ... THEN ... ELSE ... ENDIF

IFERR ... THENERR ... ELSEERR ... ENDERR

CASE
... THENCASE ... ENDTHEN
...[default]
ENDCASE

DO ... UNTIL ... ENDDO

WHILE ... REPEAT ... ENDWHILE

> OK

(09-30-2016 03:16 AM)compsystems Wrote:  5: A flag to maintain always a complex number in format (x, y) dupla

(x, y) [ENTER] (x, y) and not x+y*i and not (r, angle theta)

This already exists, without any flags. A number stays the way you entered unless you explicitly convert it to other form.

> but when the expression is simplificque is preserved?

(09-30-2016 03:16 AM)compsystems Wrote:  6: a new type of data is needed tripla (x,y,z) for geometric objects

??? Please explain better, I don't understand why you would need a separate type, you can use vectors for that.
Complex numbers are not vectors because i^2=-1, (being 'i' considered as the unit vector for the second component of the dupla). This is inconsistent with a standard vector space, hence it needs different rules than a vector. All other nth-uplas are the same.

> for example geogebra has a specific data type to tuple, as a point pairs (x,y) and triples for 3D points (x,y,z), vectors can be used, but the idea is to be more explicit in the source code. compared with hprime that is very difficult to code the lists, in some cases are lists [] -> {} in other vectors [] and other matrices [[]]

Threads

http://www.hpmuseum.org/forum/thread-6669.html
http://www.hpmuseum.org/forum/thread-6628.html

(09-30-2016 03:16 AM)compsystems Wrote:  7: Local storage in RPN

This also already exists.


> OK

8: PART is very important to analyze the input expression in a function, it must be included in the ROM =)

Thanks

[Guenter Schink]

(09-30-2016 08:45 PM)compsystems Wrote:  

(09-30-2016 03:16 AM)compsystems Wrote:  1: Use an operator optional as end line, semicolon (; ) for example.

Persistent comments also preserve the newline at the end. This means all you have to do to keep it formatted is add a comment at the end:

Code:


<< @@ This is a persistent comment, which also can be empty as in the next line
DUP @@
>>

> but if the source code has no comments, the formatting is lost, it is necessary to finalize the "sentences" somehow, the semicolon is best

Two "@@" preceding the new line do exactly what you want the ";" to do. There is no comment necessary. See above, the @@ following the DUP do the job.

Günter

[Maximilian Hohmann]

Hello,

although I am not the biggest fan of RPL myself (to put it mildly) I follow these threads with interest.

One thing puzzles me and is somehow contradicting my own programming experience:

When I add a comment to any piece of program code I usually want it to stay there, i.e. expect it to be a persistent comment. Most of "my" comments are of this type. A temporary comment, e.g. to mark a piece of code which is not finished yet or requires improvement, is rather seldom used. Normally I can remember those tings long enough (yet...).
So for me the logical thing to do would be to mark the more often needed comments in the way that requires less keystokes, which would be a single "@".

But maybe this is just me?

Regards
Max

[compsystems]

Volatile comments are a great idea. For example if you use an external editor RPL code, and want the comments to be sent to a calculator are lost, we are saving memory=)

[Guenter Schink]

(10-01-2016 01:54 PM)Maximilian Hohmann Wrote:  Hello,

although I am not the biggest fan of RPL myself (to put it mildly) I follow these threads with interest.

One thing puzzles me and is somehow contradicting my own programming experience:

When I add a comment to any piece of program code I usually want it to stay there, i.e. expect it to be a persistent comment. Most of "my" comments are of this type. A temporary comment, e.g. to mark a piece of code which is not finished yet or requires improvement, is rather seldom used. Normally I can remember those tings long enough (yet...).
So for me the logical thing to do would be to mark the more often needed comments in the way that requires less keystokes, which would be a single "@".

But maybe this is just me?

Regards
Max

Legacy RPL doesn't have persistent comments at all. I don't get the usefulness of volatile comments, once the source is compiled they're gone. Perhaps Claudio re-evaluates the nature of the comments, shouldn't be to difficult to have it the other way around.

Günter

[compsystems]

9: Super idea LISP language (prefix notation with list processing)

Use optional brackets () for operators and functions as dynamic arity

By default, the sum binary operator (+) only requires two arguments

x y + returns
'x+y'

x y z + returns
x
'y+z'

using parentheses

(x y z) + returns
'x+y+z'

this is equivalent to using other commands and delimiters

{x y z} ∑LIST returns
'x+y+z'

It implies that the type of data (x, y) obligatorily requires the comma separator is a tuple

Another example

(1 2 3) (x y z) + * returns
( 'x+y+z' '2*(x+y+z)' '3*(x+y+z)' )

equivalent to

{1 2 3 } {x y z} ∑LIST * returns
{ 'x+y+z' '2*(x+y+z)' '3*(x+y+z)' }

great idea?

[Maximilian Hohmann]

(10-01-2016 02:02 PM)compsystems Wrote:  ...we are saving memory=)

Every RPL capable calculator (with exception of the totally useless HP-28C) has more memory than I can fill by typing comments, so that should not be an issue....

[compsystems]

(10-01-2016 02:52 PM)Maximilian Hohmann Wrote:  

(10-01-2016 02:02 PM)compsystems Wrote:  ...we are saving memory=)

Every RPL capable calculator (with exception of the totally useless HP-28C) has more memory than I can fill by typing comments, so that should not be an issue....

if problem, I have a directory in which the source code contains more than 110KB in USER-RPL, included commentary and transferred only contains 70KB, you can try downloading GUI+

http://www.hpcalc.org/details/7282

[Claudio L.]

(10-01-2016 01:54 PM)Maximilian Hohmann Wrote:  Hello,

although I am not the biggest fan of RPL myself (to put it mildly) I follow these threads with interest.

One thing puzzles me and is somehow contradicting my own programming experience:

When I add a comment to any piece of program code I usually want it to stay there, i.e. expect it to be a persistent comment. Most of "my" comments are of this type. A temporary comment, e.g. to mark a piece of code which is not finished yet or requires improvement, is rather seldom used. Normally I can remember those tings long enough (yet...).
So for me the logical thing to do would be to mark the more often needed comments in the way that requires less keystokes, which would be a single "@".

But maybe this is just me?

Regards
Max

Not just you. Actually, newRPL has 3 types of comments:
@ = SINGLE LINE
@@ = SINGLE LINE PERSISTENT
@@@ = MULTI LINE

Now the compiler can either compile the comments or not into the binary, based on 2 simple rules:
* A flag that indicates if you want comments or not to be included in your code.
* The @@ comments ignore the flag, and are always included in your code.

So if you are a developer, you'll most likely keep the flag cleared so your comments are preserved across compile/decompile (all of them, not just the @@ permanent ones).

When you want to produce a "release" version of your code, you either use the new STRIPCOMMENTS command on the binary, or change the flag and recompile from source.

The permanent comment @@ is intended mostly for licensing stuff, that you want even your release binaries to carry.

For those interested in testing this: the flag in question is -30, by default this flag is set to 1, indicating comments must be stripped during compile. Just do -30 CF and all your comments will persist.

[Claudio L.]

(10-01-2016 02:11 PM)compsystems Wrote:  {1 2 3 } {x y z} ∑LIST * returns
{ 'x+y+z' '2*(x+y+z)' '3*(x+y+z)' }

great idea?

You just showed yourself the answer to that question. Every single example you have can be done with the existing list objects by replacing + with ∑LIST, everything else is the same.
So you don't really need a new type or new syntax rules to do this.

[compsystems]

(10-02-2016 03:38 AM)Claudio L. Wrote:  

(10-01-2016 02:11 PM)compsystems Wrote:  {1 2 3 } {x y z} ∑LIST * returns
( 'x+y+z' '2*(x+y+z)' '3*(x+y+z)' )

You just showed yourself the answer to that question. Every single example you have can be done with the existing list objects by replacing + with ∑LIST, everything else is the same.
So you don't really need a new type or new syntax rules to do this.

This new data type BRACES WITHOUT COMMAS, operate similar to the lists but each command or operator would work with dynamic arity, in the current PRL should I use alternative commands as SIGMALIST; PILIST; DELTALIST, ETC

BRACES WITHOUT COMAS
(Arg1 arg2 arg3 ... argN) cmd

example
(Arg1 arg2 arg3 ... argN) + -> Arg1+arg2+arg3+ ... argn

(Arg1 arg2 arg3 ... argN) * -> Arg1*arg2*arg3* ... argn

(Arg1 arg2 arg3 ... argN) - -> Arg1-arg2-arg3- ... argn

(Arg1 arg2 arg3 ... argN) / -> Arg1/arg2/arg3/ ... argn

(Arg1 arg2 arg3 ... argN) ABS -> ( ABS(Arg1) ... ABS(Argn) )


9.1 Also the new data type I want is TUPLA as does HASKELL language
Tuple:
https://en.wikipedia.org/wiki/Tuple
lists and tuples:
https://en.wikibooks.org/wiki/Haskell/Lists_and_tuples

To differentiate a tuple of a parenthetical list (Arg1 arg2 arg3 ... argN) is necessarily required to use commas

haskell examples
(True, 1)
("Hello world", False)
(4, 5, "Six", True, 'b')
( (2,3,4), True)
( (2,3,4), [2,3] )
[ (1,2), (3,4), (5,6) ] @ list
[[1,2],[8,11],[4,5]] @ list of list, same dim
[[1,2],[8,11,5],[4,5]] @ list of list

more info: http://learnyouahaskell.com/starting-out


It is better to separate data types, because the source code is more understandable, it is auto-commented, a single data type for many things creates ambiguity, this is the weak point of the hp-prime xCAS

haskell language used lists [] to contain homogeneous lists and tuples ( ... ) for different data types

#10: Use constants symbolic for TRUE and FALSE

5 3 > returns 1
best
5 3 > returns TRUE EVAL 1

'IFTE( EXPRESION==TRUE, A1, B0)'

TRUE FALSE AND returns FALSE
TRUE FALSE OR returns TRUE
---------

[compsystems]

#11 A delimiter for numeric bases only on the left side

# X d/h/o/b -> # d/h/o/b X[/color] OR d/h/o/b X #

#256d -> #d 256 or d# 256
#100h -> #h 100 or h# 100
#400o -> #o 400 or o# 400
#100000000b -> #b 100000000 or #b 100000000

[compsystems]

#12 (*, ×, ·, SPC ) multiplication sign in stack (text book view)

Show on the stack (text book view) the multiplication sign: depending of a flag on configuration menu

convert to triGraphs format with debug4x IDE http://www.debug4x.com/

PHP Code:

%%HP: T(0)A(D)F(.);
@ MADE WITH HPUserEdit 6
@  version 0.0.3 OCT 23 2016
HOME 'MULT' PGDIR
DIR
  EXAMPLE
  \<<
    {} TMENU
    FONT8STD \->FONT
    "ENTER A EXPRESSION" { "'b^2-(4*a*c)'" { 0 2 } ALG }
    INPUT OBJ\->
    SELECTMULSIGN
  \>>

  SELECTMULSIGN
  \<<
    -79 SF { } TMENU
    "MULTIPLICATION SIGN"
    { { "Asterisk *" SETFONT8STD }
      { "Cross \.x" SETFONT8CROSS }
      { "DOT \183" SETFONT8DOT }
      { "Null " SETFONT8NULL } }
      FONTTYPE
    CHOOSE
    IF
    THEN
    EVAL
      {
       { "CONT" \<< EXAMPLE \>> }
       { "EXIT" \<< 2 MENU FONT8STD \->FONT \>> }
      }
      TMENU
    ELSE
     2 MENU FONT8STD \->FONT
    END
  \>>

  SETFONT8STD
  \<<
    1 'FONTTYPE' STO FONT8STD \->FONT
  \>>

  SETFONT8CROSS
  \<<
    2 'FONTTYPE' STO FONT8CROSS \->FONT
  \>>

  SETFONT8DOT
  \<<
    3 'FONTTYPE' STO FONT8DOT \->FONT
  \>>

  SETFONT8NULL
  \<<
    4 'FONTTYPE' STO FONT8NULL \->FONT
  \>>

  FONTTYPE
  1

  FONT8STR
  "CCB20D10108000803595354554D40283800000E0E0E00000000000E0E0E00000000000E0E0E00000​000000E0E0E00000000000E0E0E00000000000E0E0E00000000000E0E0E00000000000E0E0E00000​000000E0E0E00000000000E0E0E000000000014161F16040000000E0E0E00000000000E0E0E00000​000000E0E0E00000000000E0E0E00000000000E0E0E00000000000E0E0E00000000000E0E0E00000​000000E0E0E00000000000E0E0E00000000000E0E0E00000000000E0E0E00000000000E0E0E00000​000000E0E0E00000000000E0E0E00000000000E0E0E00000000000E0E0E00000000000E0E0E00000​0080C0E1F1E1C08000F1F1F1F1F1F1F1000000000000515100000000000051510000000000000000​004040404040004000A0A0A00000000000A0A0F1A0F1A0A00040E150E041F0400030318040209181​00205050205190610040404000000000008040202020408000204080808040200000A040F140A000​00004040F1404000000000000060604020000000F100000000000000000060600000018040201000​00E01191513111E000406040404040E000E01101C02010F100E01101E00111E00080C0A090F18080​00F110F0010111E000C02010F01111E000F101804020202000E01111E01111E000E01111E1018060​000060600060600000006060006060402080402010204080000000F100F100000010204080402010​00E011018040004000E01151D15010E100E01111F111111100F01111F01111F000E01110101011E0​007090111111907000F11010F01010F100F11010F010101000E01110109111E100111111F1111111​00E04040404040E000010101011111E0001190503050901100101010101010F10011B15151111111​001111315191111100E01111111111E000F01111F010101000E011111151906100F01111F0509011​00E01110E00111E000F140404040404000111111111111E000111111A0A04040001111115151B111​001111A040A01111001111A04040404000F10180402010F100E02020202020E00000102040800100​00E08080808080E00040A0110000000000000000000000F10020204000000000000000E001E111E1​001010F0111111F0000000E1101010E1000101E1111111E1000000E011F110E00040A02070202020​000000E01111E101E01010F01111111100400060404040E0008000C0808080906010109050305090​00604040404040E0000000B051515111000000F011111111000000E0111111E0000000F01111F010​100000E11111E101010000D130101010000000E110E001F0002020702020A04000000011111111E1​000000111111A04000000011115151A000000011A040A011000000111111E101E00000F1804020F1​00C02020102020C00040404040404040006080800180806000000020518000000051A051A051A051​00000180406090F100F10011A040A0110000F111A0A0400000C14040405060400080414040405020​00F12140804021F1003070F0F1F07030000000F1A0A0A0A000204080E11111E00001804020F100F1​0010204080F100F1000080F140F12000000000006190906100004080F180400000004020F1204000​004040404051E0400040E05140404040000000215180808000402040E0909060000000E010F010E0​000000A05141410101609090F0909060000010102040A0110000C02121E02020100000E190909060​000000E15040418000000090115151A000000040A011F10000F1A0A0A0A0A0A000E011111111A0B1​000000E0E0E00000000000A05151A00000C02170207021C00040004040404040000040E15050E140​00C02120702020F10011E0111111E011001111A0F140F140004040400040404000C020E011E08060​00A000000000000000E01171317111E0006080E09060F000000041A050A0410000000000F0800000​00000000F000000000E0117171B111E000F100000000000000E0A0E00000000000004040F14040F1​00E080E020E0000000E080E080E000000080400000000000000000009090907110E1717161414161​0000000060600000000000000000408060604040E000000000E01111E000F100000050A041A05000​001090502051C10100109050A1118081003021B06071C10100400040201011E0002040E011F11111​008040E011F111110040A0E011F1111100A050E011F1111100A000E011F1111100E0A0E011F11111​00A15050F15050D100E011101011E080602040F110F010F1008040F110F010F10040A0F110F010F1​00A000F110F010F1002040E0404040E0008040E0404040E00040A0E0404040E000A000E0404040E0​0060A0217121A0600041A01131519111002040E0111111E0008040E0111111E00040A0E0111111E0​00A050E0111111E000A000E0111111E0000011A040A011000001E0915131E01000204011111111E0​00804011111111E00040A000111111E000A00011111111E000804011A0404040007020E021E02070​00E011F01111F010102040E001E111E1008040E001E111E10040A0E001E111E100A050E001E111E1​00A000E001E111E100E0A0E001E111E1000000B141F150F1000000E11010E180602040E011F110E0​008040E011F110E00040A0E011F110E000A000E011F110E000204000604040E000804000604040E0​0040A000604040E000A00000604040E00080C180E09090600041A000F011111100204000E01111E0​00804000E01111E00040A000E01111E00041A000E01111E000A00000E01111E000004000F1004000​00000061905121D000204000111111E100804000111111E10040A000111111E100A00000111111E1​008040001111E101E00010709090701010A000001111E101E0"

  FONT8STD
  \<<
    FONT8STR H\->
  \>>

  FONT8NULL
  \<<
    FONT8STR 707 "00000000000000000" REPL H\->
  \>>

  FONT8CROSS @"×"
  \<<
    FONT8STR 707 "0011A040A01100000" REPL H\->
  \>>

  FONT8DOT @"\183"
  \<<
    FONT8STR 707 "0000C0C0000000000" REPL H\->
  \>>
END

'MULT' STO MULT