diff --git a/jni/pjproject-android/third_party/gsm/add-test/add_test.c b/jni/pjproject-android/third_party/gsm/add-test/add_test.c
new file mode 100644
index 0000000..8e832df
--- /dev/null
+++ b/jni/pjproject-android/third_party/gsm/add-test/add_test.c
@@ -0,0 +1,353 @@
+/*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin.  See the accompanying file "COPYRIGHT" for
+ * details.  THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+/* $Header: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/add_test.c,v 1.2 1994/05/10 20:18:17 jutta Exp $ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "gsm.h"
+
+#include "../src/add.c"
+
+int		interactive = 1;
+
+char		* opname;
+longword	L_op1, L_op2, L_expect;
+word		op1, op2, expect;
+int		do_expect;
+
+word M_gsm_add P((word op1, word op2));
+word M_gsm_sub P((word op1, word op2));
+word M_gsm_mult P((word op1, word op2));
+word M_gsm_mult_r P((word op1, word op2));
+word M_gsm_abs P((word op1));
+longword M_gsm_L_mult P((word op1, word op2));
+longword M_gsm_L_add P((longword op1, longword op2));
+
+help()
+{
+puts( "  add a b      sub a b     mult a b   div    a b" );
+puts( "L_add A B    L_sub A B   L_mult A B   mult_r a b" );
+puts( "" );
+puts( "abs   a      norm  a        >> a b      << a b" );
+puts( "                          L_>> A B    L_<< A B" );
+
+}
+
+char * strtek P2((str, sep), char * str, char * sep) {
+
+	static char     * S = (char *)0;
+	char		* c, * base;
+
+	if (str) S = str;
+
+	if (!S || !*S) return (char *)0;
+
+	/*  Skip delimiters.
+	 */
+	while (*S) {
+		for (c = sep; *c && *c != *S; c++) ;
+		if (*c) *S++ = 0;
+		else break;
+	}
+
+	base = S;
+
+	/*   Skip non-delimiters.
+	 */
+	for (base = S; *S; S++) {
+
+		for (c = sep; *c; c++)
+			if (*c == *S) {
+				*S++ = 0;
+				return base;
+			}
+	}
+
+	return base == S ? (char *)0 : base;
+}
+
+long value P1((s), char * s)
+{
+	switch (*s) {
+	case '-': switch (s[1]) {
+		  case '\0': return MIN_WORD;
+		  case '-':  return MIN_LONGWORD;
+		  default:   break;
+		  }
+		  break;
+
+	case '+': switch (s[1]) {
+		  case '\0': return MAX_WORD;
+		  case '+':  return MAX_LONGWORD;
+		  default:   break;
+		  }
+	default:  break;
+	}
+
+	return strtol(s, (char **)0, 0);
+}
+
+char * parse P1((buf), char * buf)
+{
+	char  * s, * a;
+	long	l;
+
+	if (a = strchr(buf, '=')) *a++ = 0;
+
+	opname = s = strtek(buf, " \t("); 
+	if (!s) return (char *)0;
+
+	op1 = op2 = L_op1 = L_op2 = 0;
+
+	if (s = strtek( (char *)0, "( \t,")) {
+		op1 = L_op1 = value(s);
+		if (s = strtek( (char *)0, ", \t)")) op2 = L_op2 = value(s);
+	}
+
+	if (a) {
+		do_expect = 1;
+		while (*a == ' ' || *a == '\t') a++;
+		expect = L_expect = value(a);
+	}
+
+	return opname;
+}
+
+void fprint_word P2((f, w), FILE * f,  word w)
+{
+	if (!w) putc('0', f);
+	else fprintf(f, "0x%4.4x (%d%s)",
+		(unsigned int)w,
+		(int)w,
+		w == MIN_WORD? "/-" : (w == MAX_WORD ? "/+" : ""));
+}
+
+void print_word P1((w), word w)
+{
+	fprint_word( stdout, w );
+}
+
+void fprint_longword P2((f, w), FILE * f, longword w)
+{
+	if (!w) putc('0', f);
+	else fprintf(f, "0x%8.8x (%ld%s)",
+		w, w, w == MIN_WORD ? "/-"
+		: (w == MAX_WORD ? "/+"
+		: (w == MIN_LONGWORD ? "/--" 
+		: (w == MAX_LONGWORD ? "/++" : ""))));
+}
+
+void print_longword P1((w),longword w)
+{
+	fprint_longword(stdout, w);
+}
+
+void do_longword P1((w), longword w)
+{
+	if (interactive) print_longword(w);
+	if (do_expect) {
+		if (w != L_expect) {
+			if (!interactive) fprint_longword(stderr, w);
+			fprintf(stderr, " != %s (%ld, %ld) -- expected ",
+				opname, L_op1, L_op2 );
+			fprint_longword(stderr, L_expect);
+			putc( '\n', stderr );
+		}
+	} else if (interactive) putchar('\n');
+}
+
+void do_word P1((w), word w )
+{
+	if (interactive) print_word(w);
+	if (do_expect) {
+		if (w != expect) {
+			if (!interactive) fprint_word(stderr, w);
+			fprintf(stderr, " != %s (%ld, %ld) -- expected ",
+				opname, L_op1, L_op2 );
+			fprint_word(stderr, expect);
+			putc('\n', stderr);
+		}
+	} else if (interactive) putchar('\n');
+}
+
+int main(ac, av) char ** av;
+{
+	char	buf[299];
+	char	* c;
+	FILE 	* in;
+
+	if (ac > 2) {
+		fprintf(stderr, "Usage: %s [filename]\n", av[0]);
+fail:
+#ifdef EXIT_FAILURE
+		exit(EXIT_FAILURE);
+#else
+		exit(1);
+#endif
+	}
+	if (ac < 2) in = stdin;
+	else if (!(in = fopen(av[1], "r"))) {
+		perror(av[1]);
+		fprintf(stderr, "%s: cannot open file \"%s\" for reading\n",
+			av[0], av[1]);
+		goto fail;
+	}
+
+	interactive = isatty(fileno(in));
+
+	for (;;) {
+		if (interactive) fprintf(stderr, "? ");
+
+		if (!fgets(buf, sizeof(buf), in)) exit(0);
+		if (c = strchr(buf, '\n')) *c = 0;
+
+		if (*buf == ';' || *buf == '#') continue;
+		if (*buf == '\'') {
+			puts(buf + 1);
+			continue;
+		}
+		if (*buf == '\"') {
+			fprintf(stderr,  "%s\n", buf + 1);
+			continue;
+		}
+
+		c = parse(buf);
+
+		if (!c) continue;
+		if (!strcmp(c,   "add")) {
+			do_word(    gsm_add( op1, op2 ));
+			continue;
+		}
+		if (!strcmp(c,   "M_add")) {
+			do_word(    M_gsm_add( op1, op2 ));
+			continue;
+		}
+		if (!strcmp(c, "sub")) {
+			do_word(    gsm_sub( op1, op2 ));
+			continue;
+		}
+		if (!strcmp(c, "M_sub")) {
+			do_word(    M_gsm_sub( op1, op2 ));
+			continue;
+		}
+		if (!strcmp(c, "mult")) {
+			do_word(    gsm_mult( op1, op2 ));
+			continue;
+		}
+		if (!strcmp(c, "M_mult")) {
+			do_word(    M_gsm_mult( op1, op2 ));
+			continue;
+		}
+		if (!strcmp(c, "mult_r")) {
+			do_word(    gsm_mult_r(op1, op2));
+			continue;
+		}
+		if (!strcmp(c, "M_mult_r")) {
+			do_word(    M_gsm_mult_r(op1, op2));
+			continue;
+		}
+		if (!strcmp(c, "abs" )) {
+			do_word(    gsm_abs(op1) );
+			continue;
+		} 
+		if (!strcmp(c, "M_abs" )) {
+			do_word(    M_gsm_abs(op1) );
+			continue;
+		} 
+		if (!strcmp(c, "div" )) {
+			do_word(    gsm_div( op1, op2 ));
+			continue;
+		}
+		if (!strcmp(c,  "norm" )) {
+			do_word(	gsm_norm(L_op1));
+			continue;
+		} 
+		if (!strcmp(c,  "<<" )) {
+			do_word(    gsm_asl( op1, op2));
+			continue;
+		} 
+		if (!strcmp(c,  ">>" )) {
+			do_word(    gsm_asr( op1, op2 ));
+			continue;
+		}
+		if (!strcmp(c,  "L_mult")) {
+			do_longword( gsm_L_mult( op1, op2 ));
+			continue;
+		}
+		if (!strcmp(c,  "M_L_mult")) {
+			do_longword( M_gsm_L_mult( op1, op2 ));
+			continue;
+		}
+		if (!strcmp(c,  "L_add" )) {
+			do_longword( gsm_L_add( L_op1, L_op2 ));
+			continue;
+		} 
+		if (!strcmp(c,  "M_L_add" )) {
+			do_longword( M_gsm_L_add( L_op1, L_op2 ));
+			continue;
+		} 
+		if (!strcmp(c,  "L_sub" )) {
+			do_longword( gsm_L_sub( L_op1, L_op2 ));
+			continue;
+		} 
+		if (!strcmp(c,  "L_<<" )) {
+			do_longword(    gsm_L_asl( L_op1, L_op2 ));
+			continue;
+		} 
+		if (!strcmp(c,  "L_>>")) {
+			do_longword(    gsm_L_asr( L_op1, L_op2 ));
+			continue;
+		}
+		help();
+	}
+}
+
+#include "private.h"
+
+/*
+ * Function stubs for macro implementations of commonly used
+ * math functions
+ */
+word M_gsm_add P2((op1, op2),word op1, word op2)
+{
+	longword ltmp;
+	return GSM_ADD(op1, op2);
+}
+
+word M_gsm_sub P2((op1, op2), word op1, word op2)
+{
+	longword ltmp;
+	return GSM_SUB(op1, op2);
+}
+
+word M_gsm_mult P2((op1, op2), word op1, word op2)
+{
+	return GSM_MULT(op1, op2);
+}
+
+word M_gsm_mult_r P2((op1, op2), word op1, word op2)
+{
+	return GSM_MULT_R(op1, op2);
+}
+
+word M_gsm_abs P1((op1), word op1)
+{
+	return GSM_ABS(op1);
+}
+
+longword M_gsm_L_mult P2((op1, op2), word op1, word op2)
+{
+	return GSM_L_MULT(op1, op2);
+}
+
+longword M_gsm_L_add P2((op1, op2), longword op1, longword op2)
+{
+	ulongword utmp;
+	return GSM_L_ADD(op1, op2);
+}
diff --git a/jni/pjproject-android/third_party/gsm/add-test/add_test.dta b/jni/pjproject-android/third_party/gsm/add-test/add_test.dta
new file mode 100644
index 0000000..fe7402d
--- /dev/null
+++ b/jni/pjproject-android/third_party/gsm/add-test/add_test.dta
@@ -0,0 +1,683 @@
+;
+; Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+; Universitaet Berlin.  See the accompanying file "COPYRIGHT" for
+; details.  THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+;
+;
+;	Lines starting with ' (in the first col) are echoed.
+;	Lines starting with " (in the first col) are echoed to stderr.
+;	Lines starting with ; or empty lines are ignored.
+;
+;	The part after (including) a trailing '=' is what you expect;
+;	there will be output if the result is different.
+;
+;	-  and +  by itself mean MIN_WORD and MAX_WORD, respectively;
+;	-- and ++ mean MIN_LONGWORD and MAX_LONGWORD.
+;
+
+'test the basic arithmetic operations used for the rpe-ltd filtering.
+'
+'add ================
+'  basic
+
+	add  0  0 	=  0
+	add  7  4	= 11
+	add  4  6 	= 10
+	add  1  1 	=  2
+
+'  negative operands
+
+	add  -7  4	= -3
+	add   4 -6 	= -2
+	add  -1 -3 	= -4
+	add   7 -4	=  3
+	add  -4  6 	=  2
+
+'  positive overflow
+; (max-word = 32767)
+	add  + 1	= +
+	add  + +	= +
+	add  -1 + 	= 32766
+	add  32766 2	= +
+	add  1 32766  	= +
+
+'  underflow
+; (min-word = 32768)
+
+	add  - -1	= -
+	add  - -	= -
+	add  1 -	= -32767  
+	add  -32767 -2	= -
+	add  -1 -32766 	= -32767
+	add  -32767 -1	= -
+	add  - +	= -1
+	add  + -	= -1
+	add  0 -	= -
+	add  0 +	= +
+'
+
+'L_add ================
+'  basic 
+
+	L_add  0  0 	=  0
+	L_add  7  4	= 11
+	L_add  4  6 	= 10
+	L_add  1  1 	=  2
+
+'  negative operands
+
+	L_add  -7  4	= -3
+	L_add   4 -6 	= -2
+	L_add  -1 -3 	= -4
+	L_add   7 -4	=  3
+	L_add  -4  6 	=  2
+	L_add   0 -1 	= -1
+
+'  positive overflow
+; (max-longword = 2147483647)
+	L_add  ++ 1	= ++
+	L_add  ++ ++	= ++
+	L_add  -1 ++ 	= 2147483646
+	L_add  2147483646 2 = ++
+	L_add  1 2147483645 = 2147483646
+
+'  underflow
+; (min-longword = -2147483648)
+
+	L_add  -- -1	= --
+	L_add  -- --	= --
+	L_add  1 --	= -2147483647
+	L_add  -2147483647 -2	= --
+	L_add  -1 -2147483646 	= -2147483647
+	L_add  -2147483647 -1	= --
+	L_add  -- ++	= -1
+	L_add  ++ --	= -1
+	L_add  0 --	= --
+	L_add  0 ++	= ++
+'
+
+'sub ================
+'  basic 
+
+	sub  0  0 	=  0
+	sub  7  4	=  3
+	sub  4  6 	= -2
+	sub  1  0 	=  1
+
+'  negative operands
+
+	sub  -7  4	= -11
+	sub   4 -6 	=  10
+	sub  -1 -3 	=  2
+	sub   7 -4	=  11
+	sub  -4  6 	= -10
+
+'  positive overflow
+; (max-word = 32767)
+	sub  1 -	= +
+	sub  + +	= 0
+	sub  + 0	= +
+	sub  + -1 	= +
+	sub  + 1 	= 32766
+	sub  1 + 	= -32766 
+	sub  0 +  	= -32767
+
+'  underflow
+; (min-word = 32768)
+
+	sub  - -1	= -32767
+	sub  - 1	= -
+	sub  - -	= 0
+	sub  - +	= -
+	sub  + -	= +
+	sub  1 -	= +
+	sub  -1 -	= +
+	sub  -32767 2	= -
+	sub  0 -	= +
+' 
+
+'L_sub ================
+'  basic 
+
+	L_sub  0  0 	=  0
+	L_sub  7  4	=  3
+	L_sub  4  6 	= -2
+	L_sub  1  0 	=  1
+
+'  negative operands
+
+	L_sub  -7  4	= -11
+	L_sub   4 -6 	=  10
+	L_sub  -1 -3 	=  2
+	L_sub   7 -4	=  11
+	L_sub  -4  6 	= -10
+
+'  positive overflow
+	L_sub  1 --	= ++
+	L_sub  ++ ++	= 0
+	L_sub  ++ 0	= ++
+	L_sub  ++ -1 	= ++
+	L_sub  ++ 1 	=  2147483646
+	L_sub  1 ++ 	= -2147483646
+	L_sub  0 ++  	= -2147483647
+
+'  underflow
+
+	L_sub  -- -1	= -2147483647
+	L_sub  -- 1	= --
+	L_sub  -- --	= 0
+	L_sub  -- ++	= --
+	L_sub  + --	= ++
+	L_sub  1 --	= ++
+	L_sub  -1 --	= ++
+	L_sub  -2147483647 2 = --
+	L_sub  0 --	= ++
+
+'
+'abs ================
+'  basic 
+
+	abs	   0	=   0
+	abs	   2	=   2
+	abs	-459	= 459
+
+'  overflow
+
+	abs	 +	=   +
+	abs	 -	=   +
+	abs 	-32767  =   +
+	abs 	 32766  = 32766
+	abs 	-32766  = 32766
+
+'
+'mult ================
+;  actually, a * b >> 15
+
+'  basic 
+	mult	0  0		= 0
+	mult	0x100 0x100	= 2
+	mult	4711 0x4000	= 2355
+
+'  negative operands
+	mult	-1  0		=  0
+
+	mult	-0x100   0x100	= -2
+	mult	 0x100  -0x100	= -2
+	mult	-0x100  -0x100	=  2
+
+	mult	-4711   0x4000	= -2356
+	mult	 4711  -0x4000	= -2356
+	mult	-4711  -0x4000	=  2355
+
+'  overflow
+	mult	+ + 	 = 32766
+	mult	+ 0x4000 = 0x3fff
+	mult	0x4000 + = 0x3fff
+	mult	+ 1	 = 0
+	mult	+ 2	 = 1
+	mult	+ 3	 = 2
+
+'  underflow
+	mult	- - 	 = +
+	mult	- + 	 = -32767
+	mult	+ - 	 = -32767
+	mult	- 1	 = -1
+	mult	- 2	 = -2
+	mult	- 3	 = -3
+
+'
+'mult_r ================
+;  actually, (a * b + 16384) >> 15
+
+'  basic 
+	mult_r	0  0		= 0
+	mult_r	0x100 0x100	= 2
+	mult_r	4711 0x4000	= 2356
+
+'  negative operands
+	mult_r	-1  0		=  0
+
+	mult_r	-0x100   0x100	= -2
+	mult_r	 0x100  -0x100	= -2
+	mult_r	-0x100  -0x100	=  2
+
+	mult_r	-4711   0x4000	= -2355
+	mult_r	 4711  -0x4000	= -2355
+	mult_r	-4711  -0x4000	=  2356
+
+'  overflow
+	mult_r	+ + 	 = 32766
+	mult_r	+ 32766	 = 32765
+	mult_r	32766 +	 = 32765
+	mult_r	+ 0x4000 = 0x4000
+	mult_r	0x4000 + = 0x4000
+	mult_r	+ 0x4001 = 0x4000
+	mult_r	0x4001 + = 0x4000
+	mult_r	+ 2	 = 2
+	mult_r	+ 1	 = 1
+	mult_r	1 +	 = 1
+	mult_r	+ 0	 = 0
+	mult_r	0 +	 = 0
+
+'  underflow
+	mult_r	- - 	 = +
+	mult_r	- + 	 = -32767
+	mult_r	+ - 	 = -32767
+	mult_r	- 1	 = -1
+	mult_r	- 2	 = -2
+	mult_r	- 3	 = -3
+
+'
+'L_mult ================
+;  actually, (a * b) << 1
+;  assert (a != MIN_WORD && b != MIN_WORD)
+
+'  basic 
+	L_mult	0  0	= 0
+	L_mult	2  3	= 12
+	L_mult	4711 5	= 47110
+
+'  negative operands
+
+	L_mult	-2  3	= -12
+	L_mult	 2 -3	= -12
+	L_mult	-2 -3	=  12
+	L_mult -4711  5	= -47110
+	L_mult	4711 -5	= -47110
+	L_mult -4711 -5	=  47110
+
+'  overflow
+	L_mult	+ + 	 = 2147352578
+	L_mult	+ -32767 = -2147352578
+	L_mult	-32767 + = -2147352578
+	L_mult	+ 2	 = 131068
+	L_mult	+ 1	 = 65534
+	L_mult	1 +	 = 65534
+	L_mult	+ 0	 = 0
+	L_mult	0 +	 = 0
+
+'
+'div ================
+;  actually, (32767 * a) / b
+;  assert (a > 0 && b >= a)
+
+'  basic 
+	div	1 1		= +
+	div	4711 4711 	= +
+	div	5 10		= 0x4000
+	div	5 20		= 0x2000
+	div	5 40		= 0x1000
+
+'  overflow
+	div	+ + 		= +
+	div	0x4000 +	= 0x4000
+	div	1 +		= 1
+	div	1 2		= 0x4000
+'
+'norm ================
+
+'  positive
+	norm	1		= 30
+	norm	2		= 29
+	norm	3		= 29
+	norm	4		= 28
+	norm	5		= 28
+; etc, etc...
+	norm	0x08000000	= 3
+	norm	0x10000000	= 2
+	norm	0x20000000	= 1
+	norm	0x20000001	= 1
+	norm	0x3fffffff	= 1
+	norm	0x40000000	= 0
+	norm	0x40000001	= 0
+	norm	0x4ffffffe	= 0
+	norm	++		= 0
+
+'  negative
+	norm	-1		= 31
+	norm	-2		= 30
+	norm	-3		= 29
+	norm	-4		= 29
+	norm	-5		= 28
+; etc, etc...
+	norm	0x4fffffff	= 0
+	norm	--		= 0
+'
+'>> ================
+
+'  basic 
+	>>	1 1		= 0
+	>>	4 2		= 1
+	>>	0x1100 5	= 0x88
+
+'  negative operand
+
+	>>	1 -1		= 2
+	>>	1 -2		= 4
+	>>	0x88 -5		= 0x1100
+
+'  overflow
+	>>	-1 4711		= -1
+	>>	1  4711		= 0
+	>>	-4711 4711 	= -1
+	>>	4711 4711 	= 0
+	>>	+ 1		=  16383
+	>>	- 1		= -16384
+'
+'L_>> ================
+
+'  basic 
+	L_>>	1 1		= 0
+	L_>>	4 2		= 1
+	L_>>	0x1100 5	= 0x88
+
+'  negative operand
+
+	L_>>	1 -1		= 2
+	L_>>	1 -2		= 4
+	L_>>	0x88 -5		= 0x1100
+
+'  overflow
+	L_>>	-1 4711		= -1
+	L_>>	1  4711		= 0
+	L_>>	-4711 4711 	= -1
+	L_>>	4711 4711 	= 0
+	L_>>	++ 1		=  1073741823
+	L_>>	-- 1		= -1073741824
+
+'
+'<< ================
+
+'  basic 
+	<<	1 1		= 2
+	<<	4 2		= 16
+	<<	0x0088 5	= 0x1100
+
+'  negative operand
+
+	<<	1 -1		= 0
+	<<	4 -2		= 1
+	<<	0x1100 -5	= 0x0088
+
+'  overflow
+	<<	-1 4711		= 0
+	<<	1  4711		= 0
+	<<	-4711 4711 	= 0
+	<<	4711 4711 	= 0
+	<<	4711 -4711 	= 0
+	<<	-4711 -4711 	= -1
+	<<	+ 1		= 0xfffe
+	<<	-1 1		= 0xfffe
+	<<	- 1		= 0
+'
+'L_<< ================
+
+'  basic 
+	L_<<	1 1		= 2
+	L_<<	4 2		= 16
+	L_<<	0x0088 5	= 0x1100
+
+'  negative operand
+
+	L_<<	1 -1		= 0
+	L_<<	4 -2		= 1
+	L_<<	0x1100 -5	= 0x0088
+
+'  overflow
+	L_<<	-1 4711		= 0
+	L_<<	1  4711		= 0
+	L_<<	-4711 4711 	= 0
+	L_<<	4711 4711 	= 0
+	L_<<	4711 -4711 	= 0
+	L_<<	-4711 -4711 	= -1
+	L_<<	++ 1		= -2
+	L_<<	-1 1		= -2
+	L_<<	-- 1		= 0
+
+'macros
+'
+'add ================
+'  basic
+
+	M_add  0  0 	=  0
+	M_add  7  4	= 11
+	M_add  4  6 	= 10
+	M_add  1  1 	=  2
+
+'  negative operands
+
+	M_add  -7  4	= -3
+	M_add   4 -6 	= -2
+	M_add  -1 -3 	= -4
+	M_add   7 -4	=  3
+	M_add  -4  6 	=  2
+
+'  positive overflow
+; (max-word = 32767)
+	M_add  + 1	= +
+	M_add  + +	= +
+	M_add  -1 + 	= 32766
+	M_add  32766 2	= +
+	M_add  1 32766  	= +
+
+'  underflow
+; (min-word = 32768)
+
+	M_add  - -1	= -
+	M_add  - -	= -
+	M_add  1 -	= -32767  
+	M_add  -32767 -2 = -
+	M_add  -1 -32766 = -32767
+	M_add  -32767 -1 = -
+	M_add  - +	= -1
+	M_add  + -	= -1
+	M_add  0 -	= -
+	M_add  0 +	= +
+'
+
+'L_add ================
+'  basic 
+
+	M_L_add  0  0 	=  0
+	M_L_add  7  4	= 11
+	M_L_add  4  6 	= 10
+	M_L_add  1  1 	=  2
+
+'  negative operands
+
+	M_L_add  -7  4	= -3
+	M_L_add   4 -6 	= -2
+	M_L_add  -1 -3 	= -4
+	M_L_add   7 -4	=  3
+	M_L_add  -4  6 	=  2
+	M_L_add   0 -1 	= -1
+
+'  positive overflow
+; (max-longword = 2147483647)
+	M_L_add  ++ 1	= ++
+	M_L_add  ++ ++	= ++
+	M_L_add  -1 ++ 	= 2147483646
+	M_L_add  2147483646 2 = ++
+	M_L_add  1 2147483645 = 2147483646
+
+'  underflow
+; (min-longword = -2147483648)
+
+	M_L_add  -- -1	= --
+	M_L_add  -- --	= --
+	M_L_add  1 --	= -2147483647
+	M_L_add  -2147483647 -2	= --
+	M_L_add  -1 -2147483646 	= -2147483647
+	M_L_add  -2147483647 -1	= --
+	M_L_add  -- ++	= -1
+	M_L_add  ++ --	= -1
+	M_L_add  0 --	= --
+	M_L_add  0 ++	= ++
+'
+
+'sub ================
+'  basic 
+
+	M_sub  0  0 	=  0
+	M_sub  7  4	=  3
+	M_sub  4  6 	= -2
+	M_sub  1  0 	=  1
+
+'  negative operands
+
+	M_sub  -7  4	= -11
+	M_sub   4 -6 	=  10
+	M_sub  -1 -3 	=  2
+	M_sub   7 -4	=  11
+	M_sub  -4  6 	= -10
+
+'  positive overflow
+; (max-word = 32767)
+	M_sub  1 -	= +
+	M_sub  + +	= 0
+	M_sub  + 0	= +
+	M_sub  + -1 	= +
+	M_sub  + 1 	= 32766
+	M_sub  1 + 	= -32766 
+	M_sub  0 +  	= -32767
+
+'  underflow
+; (min-word = 32768)
+
+	M_sub  - -1	= -32767
+	M_sub  - 1	= -
+	M_sub  - -	= 0
+	M_sub  - +	= -
+	M_sub  + -	= +
+	M_sub  1 -	= +
+	M_sub  -1 -	= +
+	M_sub  -32767 2	= -
+	M_sub  0 -	= +
+' 
+'
+'abs ================
+'  basic 
+
+	M_abs	   0	=   0
+	M_abs	   2	=   2
+	M_abs	-459	= 459
+
+'  overflow
+
+	M_abs	 +	=   +
+	M_abs	 -	=   +
+	M_abs 	-32767  =   +
+	M_abs 	 32766  = 32766
+	M_abs 	-32766  = 32766
+
+'
+'mult ================
+;  actually, a * b >> 15
+
+'  basic 
+	M_mult	0  0		= 0
+	M_mult	0x100 0x100	= 2
+	M_mult	4711 0x4000	= 2355
+
+'  negative operands
+	M_mult	-1  0		=  0
+
+	M_mult	-0x100   0x100	= -2
+	M_mult	 0x100  -0x100	= -2
+	M_mult	-0x100  -0x100	=  2
+
+	M_mult	-4711   0x4000	= -2356
+	M_mult	 4711  -0x4000	= -2356
+	M_mult	-4711  -0x4000	=  2355
+
+'  overflow
+	M_mult	+ + 	 = 32766
+	M_mult	+ 0x4000 = 0x3fff
+	M_mult	0x4000 + = 0x3fff
+	M_mult	+ 1	 = 0
+	M_mult	+ 2	 = 1
+	M_mult	+ 3	 = 2
+
+'  underflow
+;	M_mult - - 	= +			assert !(a == b && b == MIN_WORD)
+ 	M_mult - -32767	= +
+ 	M_mult -32767 -	= +
+	M_mult	- + 	= -32767
+	M_mult	+ - 	= -32767
+	M_mult	- 1	= -1
+	M_mult	- 2	= -2
+	M_mult	- 3	= -3
+
+'
+'mult_r ================
+;  actually, (a * b + 16384) >> 15
+
+'  basic 
+	M_mult_r 0  0		= 0
+	M_mult_r 0x100 0x100	= 2
+	M_mult_r 4711 0x4000	= 2356
+
+'  negative operands
+	M_mult_r -1  0		=  0
+
+	M_mult_r -0x100   0x100	= -2
+	M_mult_r  0x100  -0x100	= -2
+	M_mult_r -0x100  -0x100	=  2
+
+	M_mult_r -4711   0x4000	= -2355
+	M_mult_r  4711  -0x4000	= -2355
+	M_mult_r -4711  -0x4000	=  2356
+
+'  overflow
+	M_mult_r + + 	 = 32766
+	M_mult_r + 32766  = 32765
+	M_mult_r 32766 +  = 32765
+	M_mult_r + 0x4000 = 0x4000
+	M_mult_r 0x4000 + = 0x4000
+	M_mult_r + 0x4001 = 0x4000
+	M_mult_r 0x4001 + = 0x4000
+	M_mult_r + 2	 = 2
+	M_mult_r + 1	 = 1
+	M_mult_r 1 +	 = 1
+	M_mult_r + 0	 = 0
+	M_mult_r 0 +	 = 0
+
+'  underflow
+;	M_mult_r - - 	 = +			assert !(a == b && b == MIN_WORD)
+ 	M_mult_r - -32767 = +
+ 	M_mult_r -32767 - = +
+	M_mult_r - + 	 = -32767
+	M_mult_r + - 	 = -32767
+	M_mult_r - 1	 = -1
+	M_mult_r - 2	 = -2
+	M_mult_r - 3	 = -3
+
+'
+'L_mult ================
+;  actually, (a * b) << 1
+;  assert (a != MIN_WORD && b != MIN_WORD)
+
+'  basic 
+	M_L_mult	0  0	= 0
+	M_L_mult	2  3	= 12
+	M_L_mult	4711 5	= 47110
+
+'  negative operands
+
+	M_L_mult	-2  3	= -12
+	M_L_mult	 2 -3	= -12
+	M_L_mult	-2 -3	=  12
+	M_L_mult -4711  5	= -47110
+	M_L_mult	4711 -5	= -47110
+	M_L_mult -4711 -5	=  47110
+
+'  overflow
+ 	M_L_mult	+ + 	 = 2147352578
+	M_L_mult	+ -32767 = -2147352578
+	M_L_mult	-32767 + = -2147352578
+	M_L_mult	+ 2	 = 131068
+	M_L_mult	+ 1	 = 65534
+	M_L_mult	1 +	 = 65534
+	M_L_mult	+ 0	 = 0
+	M_L_mult	0 +	 = 0
+