#include <perms.h>
static const int R0 = 0;
static const int R1 = 1;
static const int R2 = 2;
static const int R3 = 3;
static const int R4 = 4;
static const int R5 = 5;
static const int R6 = 6;
static const int R7 = 7;
static const int R8 = 8;
static const int R9 = 9;
static const int R10 = 10;
static const int R11 = 11;
static const int R12 = 12;
static const int R13 = 13;
static const int R14 = 14;
static const int R15 = 15;
static const int Sb = R9;
static const int Fp = R10;
static const int Sp = R12;
static const int Pc = R15;
static const int Link = R14;
static const int F0 = 16 + 0;
static const int F1 = 16 + 1;
void Callsignal(void);
extern void Signal(void) {
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Asstest(void) {
  asm("MOV   R1, #8");
  asm("MOV   R2, #1");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Rtmonitor(void) {
  asm("MOV   R1, #4");
  asm("MOV   R2, #0");
  asm("MOV   R3, #7");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Swjump(void) {
  asm("BIC     Link, Link, #16_FC00 0000 {clear top bits}");
  asm("LDR     R2, [Link, #4]            {address of switch vector} {001}");
  asm("LDMIA   R2!, <R4, R5>             {R4=UB, R5=LB}");
  asm("CMPS    R4, R1");
  asm("SUBGES  R5, R1, R5");
  asm("MOVGE   Pc, Link                  {return to LDR_Pc,[R2,R5,%LSL #2]}");
  asm("MOV     R3, R1        {index}");
  asm("MOV     R2, #4        {SUB}");
  asm("MOV     R1, #6        {EVENT, switch label error}");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Primdiv(void) {
  __label__ L0;
  __label__ L1;
  __label__ L2;
  asm("CMPS     R2, #0");
  asm("BNE      L0");
  asm("MOV   R1, #14");
  asm("MOV   R2, #2");
  asm("MOV   R3, #0");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
L0:
  asm("MOV      R4, #1                {result sign}");
  asm("RSBLT    R2, R2, #0            {R2 = |R2|}");
  asm("RSBLT    R4, R4, #0            {invert result sign}");
  asm("ADDS     R5, R1, #0            {preserve Dividend & test sign}");
  asm("RSBLT    R1, R1, #0            {R1 = |R1|}");
  asm("RSBLT    R4, R4, #0            {invert result sign}");
  asm("MOV      R3, #1");
L1:
  asm("CMPS     R2, #16_80000000");
  asm("CMPCCS   R2, R1");
  asm("MOVCC    R2, R2, %LSL #1");
  asm("MOVCC    R3, R3, %LSL #1");
  asm("BCC      L1");
  asm("MOV      R0, #0");
L2:
  asm("CMPS     R1, R2");
  asm("SUBCS    R1, R1, R2");
  asm("ADDCS    R0, R0, R3");
  asm("MOVS     R3, R3, %LSR #1");
  asm("MOVNE    R2, R2, %LSR #1");
  asm("BNE      L2");
  asm("CMPS     R4, #0");
  asm("RSBLT    R0, R0, #0         {negate quotient}");
  asm("CMPS     R5, #0");
  asm("RSBLT    R1, R1, #0         {negate remainder}");
  asm("MOV      Pc, Link");
}
extern void Primudiv(void) {
  __label__ L0;
  __label__ L1;
  __label__ L2;
  asm("CMPS     R2, #0");
  asm("BNE      L0");
  asm("MOV   R1, #14");
  asm("MOV   R2, #2");
  asm("MOV   R3, #0");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
L0:
  asm("MOV      R3, #1");
L1:
  asm("CMPS     R2, #16_80000000");
  asm("CMPCCS   R2, R1");
  asm("MOVCC    R2, R2, %LSL #1");
  asm("MOVCC    R3, R3, %LSL #1");
  asm("BCC      L1");
  asm("MOV      R0, #0");
L2:
  asm("CMPS     R1, R2");
  asm("SUBCS    R1, R1, R2");
  asm("ADDCS    R0, R0, R3");
  asm("MOVS     R3, R3, %LSR #1");
  asm("MOVNE    R2, R2, %LSR #1");
  asm("BNE      L2");
  asm("MOV      Pc, Link");
}
extern void Sconc(void) {
  __label__ L1;
  asm("LDRB     R4, [R3], #1         {length of new bit}");
L1:
  asm("SUBS     R4, R4, #1");
  asm("LDRGEB   R5, [R3], #1       {next character}");
  asm("STRGEB   R5, [R2], #1       {plug it into destination}");
  asm("BGT      L1");
  asm("MOV      Pc, Link");
}
extern void Scomp(void) {
  __label__ S1;
  __label__ S2;
  asm("LDRB    R3, [R1], #1");
  asm("LDRB    R4, [R2], #1");
  asm("SUBS    R3, R3, R4");
  asm("ADDLT   R4, R3, R4        {r4 is now the minimum length}");
S1:
  asm("SUBS    R4, R4, #1");
  asm("BLT     S2                {common bits the same - use R3 for answer}");
  asm("LDRB    R5, [R1], #1");
  asm("LDRB    R6, [R2], #1");
  asm("CMPS    R5, R6");
  asm("BEQ     S1");
  asm("MOV     Pc, Link          {characters differ, return CC}");
S2:
  asm("CMPS    R3, #0            {set CC on difference in lengths}");
  asm("MOV     Pc, Link          {return}");
}
extern void Cscomp(void) {
  __label__ L1;
  asm("LDRB    R0, [R2]           {length of string}");
  asm("CMPS    R0, #1");
  asm("MOVLT   Pc, Link           {compare against null - return LT}");
  asm("LDRB    R0, [R2, #1]       {first character}");
  asm("BEQ     L1");
  asm("CMPS    R0, R1");
  asm("MOVNE   Pc, Link");
  asm("MOV     R0, #256           {to give >}");
L1:
  asm("CMPS    R0, R1             {lengths the same}");
  asm("MOV     Pc, Link           {return}");
}
extern void Sres(void) {
  __label__ L1;
  __label__ L2;
  __label__ L3;
  asm("LDRB    R7, [R1], #1         {length of source}");
  asm("LDRB    R3, [R2], #1         {length of pattern}");
  asm("MOVS    R6, R3               {test the length}");
  asm("MOVEQ   Pc, Link             {null pattern -> success}");
  asm("LDRB    R0, [R2], #1         {first character of pattern}");
  asm("ADD     R4, R7, R1");
  asm("SUB     R4, R4, R3           {limit of search}");
  asm("MOV     R5, R1");
L1:
  asm("CMPS    R5, R4               {check against limit}");
  asm("MOVGT   Pc, R14              {greater implies failure}");
  asm("LDRB    R6, [R5], #1         {look for first character}");
  asm("CMPS    R6, R0");
  asm("BNE     L1");
  asm("SUBS    R7, R3, #2           {found}");
  asm("BLT     L3                   {only searching for a single character}");
L2:
  asm("LDRB    R8, [R5, R7]         {compare the rest}");
  asm("LDRB    R6, [R2, R7]");
  asm("CMPS    R8, R6");
  asm("BNE     L1                   {no match, continue looking for first "
      "character}");
  asm("SUBS    R7, R7, #1");
  asm("BGT     L2");
L3:
  asm("SUB     R5, R5, #1           {complete match}");
  asm("SUB     R7, R5, R1           {length of left fragment}");
  asm("SUB     R6, R4, R5           {length of right fragment}");
  asm("ADD     R3, R3, R5           {address of right fragment}");
  asm("CMPS    R3, R3               {set CC=EQ - success}");
  asm("MOV     Pc, Link             {return}");
}
extern void Frag1(void) {
  __label__ F1;
  asm("STRB    R7, [R2],#1       {plug length}");
F1:
  asm("SUBS    R7, R7, #1");
  asm("MOVLT   Pc, Link          {all done}");
  asm("LDRB    R0, [R1], #1      {copy next character}");
  asm("STRB    R0, [R2], #1");
  asm("BR      F1");
}
extern void Frag2(void) {
  __label__ F1;
  asm("STRB    R6, [R2],#1       {plug length}");
F1:
  asm("SUBS    R6, R6, #1");
  asm("MOVLT   Pc, Link          {all done}");
  asm("LDRB    R0, [R3], #1      {copy next character}");
  asm("STRB    R0, [R2], #1");
  asm("BR      F1");
}
extern void Resflop(void) {
  asm("MOVEQ   Pc, Link          {return if OK}");
  asm("MOV   R1, #4");
  asm("MOV   R2, #0");
  asm("MOV   R3, #8");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Primcomp(void) {
  __label__ L;
  asm("CMPS    R0, #0         {beware of null strings}");
  asm("MOVEQ   Pc, Link       {return equal}");
L:
  asm("LDRB    R3, [R1], #1");
  asm("LDRB    R4, [R2], #1");
  asm("CMPS    R3, R4");
  asm("MOVNE   Pc, Link");
  asm("SUBS    R0, R0, #1");
  asm("BNE     L");
  asm("MOV     Pc, Link       {return equal}");
}
extern void Sjam(void) {
  __label__ L1;
  asm("LDRB     R3, [R1],#1      {actual length}");
  asm("CMPS     R0, R3           {compare with max+1}");
  asm("SUBLE    R3, R0, #1       {replace with max if nesc}");
  asm("STRB     R3, [R2], #1     {plug new length}");
L1:
  asm("SUBS     R3, R3, #1");
  asm("MOVLT    Pc, Link");
  asm("LDRB     R0, [R1], #1");
  asm("STRB     R0, [R2], #1");
  asm("BR       L1");
}
extern void Intexp(void) {
  __label__ Ng;
  __label__ L1;
  __label__ L2;
  asm("MOV      R0, R1         {preserve multiplier}");
  asm("MOV      R1, #1");
  asm("CMPS     R2, #0");
  asm("BLE      Ng");
L1:
  asm("MOV      R3, R1         {Ra}");
  asm("MOV      R5, R0         {Rb}");
  asm("MOV      R1, #0");
L2:
  asm("MOVS     R3, R3, %LSR #1");
  asm("ADDCS    R1, R1, R5");
  asm("ADD      R5, R5, R5");
  asm("BNE      L2");
  asm("SUBS     R2, R2, #1");
  asm("BNE      L1");
Ng:
  asm("MOVEQ    Pc, Link       {return 1 if zero}");
  asm("MOV   R1, #4");
  asm("MOV   R2, #0");
  asm("MOV   R3, #20");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Dynamic1(void) {
  __label__ M1;
  __label__ M2;
  __label__ No;
  asm("MOV     R2, #0      {calculate zero'th disp}");
  asm("MOV     R0, R5      {save multiplier}");
  asm("MOV     R6, R3      {save lower bound}");
  asm("MOV     R7, R4      {save upper bound}");
  asm("MOV     R8, R5      {save multiplier}");
M1:
  asm("MOVS    R0, R0, %LSR #1");
  asm("ADDCS   R2, R2, R6");
  asm("ADD     R6, R6, R6");
  asm("BNE     M1          {R2 = Lower*Item}");
  asm("RSB     R2, R2, #0  {R2 = -Lower*Item = Zero'th Disp}");
  asm("MOV     R1, #0      {calculate total size}");
  asm("ADD     R7, R7, #1");
M2:
  asm("MOVS    R8, R8, %LSR #1");
  asm("ADDCS   R1, R1, R7");
  asm("ADD     R7, R7, R7");
  asm("BNE     M2          {R1 = (Upper+1)*Item}");
  asm("ADDS    R1, R1, R2  {R1 = (Upper+1)*Item-Lower*Item = "
      "(Upper-Lower+1)*Item}");
  asm("BLT     No          {inside-out}");
  asm("ADD     R1, R1, #3");
  asm("BIC     R1, R1, #3  {round up}");
  asm("MOV     R0, #1      {dimension}");
  asm("STMDB   Sp!, <R0,R1,R2,R3,R4,R5>");
  asm("MOV     R3, Sp      {address of dope vector}");
  asm("MOV     Pc, Link");
No:
  asm("MOV   R1, #4");
  asm("MOV   R2, #0");
  asm("MOV   R3, #9");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Dynamic2(void) {
  __label__ L1;
  __label__ L2;
  __label__ L3;
  __label__ L4;
  __label__ No;
  asm("SUB     R5, R7, R6");
  asm("ADDS    R5, R5, #1  {number of elements in second dimension, M2}");
  asm("BLT     No          {inside out}");
  asm("STMDB   Sp!, <R3,R4,R5,R6,R7,R8>  {half of dope vector}");
  asm("SUB     R4, R4, R3");
  asm("ADDS    R4, R4, #1        {elements in first dimension, M1}");
  asm("BLT     No");
  asm("MOV     R0, R8            {protect item size}");
  asm("MOV     R7, #0");
L1:
  asm("MOVS    R0, R0, %LSR #1");
  asm("ADDCS   R7, R7, R5");
  asm("ADD     R5, R5, R5");
  asm("BNE     L1                {R7 = M2*Item = T1}");
  asm("MOV     R0, R8");
  asm("MOV     R2, #0");
L2:
  asm("MOVS    R0, R0, %LSR #1");
  asm("ADDCS   R2, R2, R6");
  asm("ADD     R6, R6, R6");
  asm("BNE     L2                {R2 = L2*Item}");
  asm("MOV     R1, R7");
  asm("MOV     R0, #0");
L3:
  asm("MOVS    R1, R1, %LSR #1");
  asm("ADDCS   R0, R0, R3");
  asm("ADD     R3, R3, R3");
  asm("BNE     L3                {R0 = L1*T1}");
  asm("ADD     R2, R2, R0        {R2 = L2*item + L1*T1}");
  asm("RSB     R2, R2, #0        {R2 = -R2 = disp of A(0)}");
  asm("MOV     R1, #0");
L4:
  asm("MOVS    R4, R4, %LSR #1");
  asm("ADDCS   R1, R1, R7");
  asm("ADD     R7, R7, R7");
  asm("BNE     L4                {R1 = T1*M1 = total size}");
  asm("ADD     R1, R1, #3");
  asm("BIC     R1, R1, #3        {round up}");
  asm("MOV     R0, #2            {2 dimensions}");
  asm("STMDB   Sp!, <R0,R1,R2>");
  asm("MOV     R3, Sp            {pointer to dope vector}");
  asm("MOV     Pc, Link");
No:
  asm("MOV   R1, #4");
  asm("MOV   R2, #0");
  asm("MOV   R3, #1");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Dynamicn(void) {
  asm("MOV   R1, #4");
  asm("MOV   R2, #0");
  asm("MOV   R3, #1");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Setadd(void) {
  asm("LDMIA   R8,   <R0,R1,R2,R3>");
  asm("LDMIA   R11!, <R4,R5,R6,R7>");
  asm("ORR     R0, R0, R4");
  asm("ORR     R1, R1, R5");
  asm("ORR     R2, R2, R6");
  asm("ORR     R3, R3, R7");
  asm("STMIA   R8!,  <R0,R1,R2,R3>");
  asm("LDMIA   R8,   <R0,R1,R2,R3>");
  asm("LDMIA   R11!, <R4,R5,R6,R7>");
  asm("ORR     R0, R0, R4");
  asm("ORR     R1, R1, R5");
  asm("ORR     R2, R2, R6");
  asm("ORR     R3, R3, R7");
  asm("STMIA   R8!, <R0,R1,R2,R3>");
  asm("MOV     Pc, Link");
}
extern void Setsub(void) {
  asm("LDMIA   R8,   <R0,R1,R2,R3>");
  asm("LDMIA   R11!, <R4,R5,R6,R7>");
  asm("BIC     R0, R0, R4");
  asm("BIC     R1, R1, R5");
  asm("BIC     R2, R2, R6");
  asm("BIC     R3, R3, R7");
  asm("STMIA   R8!,  <R0,R1,R2,R3>");
  asm("LDMIA   R8,   <R0,R1,R2,R3>");
  asm("LDMIA   R11!, <R4,R5,R6,R7>");
  asm("BIC     R0, R0, R4");
  asm("BIC     R1, R1, R5");
  asm("BIC     R2, R2, R6");
  asm("BIC     R3, R3, R7");
  asm("STMIA   R8!, <R0,R1,R2,R3>");
  asm("MOV     Pc, Link");
}
extern void Setinter(void) {
  asm("LDMIA   R8,   <R0,R1,R2,R3>");
  asm("LDMIA   R11!, <R4,R5,R6,R7>");
  asm("AND     R0, R0, R4");
  asm("AND     R1, R1, R5");
  asm("AND     R2, R2, R6");
  asm("AND     R3, R3, R7");
  asm("STMIA   R8!,  <R0,R1,R2,R3>");
  asm("LDMIA   R8,   <R0,R1,R2,R3>");
  asm("LDMIA   R11!, <R4,R5,R6,R7>");
  asm("AND     R0, R0, R4");
  asm("AND     R1, R1, R5");
  asm("AND     R2, R2, R6");
  asm("AND     R3, R3, R7");
  asm("STMIA   R8!, <R0,R1,R2,R3>");
  asm("MOV     Pc, Link");
}
extern void Setge(void) {
  asm("LDMIA    R8! , <R0,R1,R2,R3>");
  asm("LDMIA    R11!, <R4,R5,R6,R7>");
  asm("BICS     R0, R4, R0");
  asm("BICEQS   R1, R5, R1");
  asm("BICEQS   R2, R6, R2");
  asm("BICEQS   R3, R7, R3");
  asm("MOVNE    Pc, Link");
  asm("LDMIA    R8! , <R0,R1,R2,R3>");
  asm("LDMIA    R11!, <R4,R5,R6,R7>");
  asm("BICS     R0, R4, R0");
  asm("BICEQS   R1, R5, R1");
  asm("BICEQS   R2, R6, R2");
  asm("BICEQS   R3, R7, R3");
  asm("MOV      Pc, Link");
}
extern void Setin(void) {
  __label__ No;
  asm("CMPS   R1, #255");
  asm("BHI    No");
  asm("AND    R3, R1, #7            {bit index into byte}");
  asm("LDRB   R0, [R2, R1, %LSR #3]");
  asm("MOV    R0, R0, %LSR R3       {get relevant bit to least significant "
      "end}");
  asm("TSTS   R0, #1                {set CC}");
  asm("MOV    Pc, Link");
No:
  asm("CMPS   R1, R1                {set EQ i.e. False}");
  asm("MOV    Pc, Link");
}
extern void Setbit(void) {
  __label__ No;
  asm("CMPS   R1, #255");
  asm("BHI    No");
  asm("AND    R3, R1, #7           {bit index into byte}");
  asm("LDRB   R0, [R8, R1, %LSR #3]");
  asm("MOV    R4, #1");
  asm("ORR    R0, R0, R4, %LSL R3");
  asm("STRB   R0, [R8, R1, %LSR #3]");
  asm("MOV    Pc, Link");
No:
  asm("MOV    R3, R1");
  asm("MOV    R1, #14");
  asm("MOV    R2, #3");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Clearbit(void) {
  __label__ No;
  asm("CMPS   R1, #255");
  asm("BHI    No");
  asm("AND    R3, R1, #7           {bit index into byte}");
  asm("LDRB   R0, [R8, R1, %LSR #3]");
  asm("MOV    R4, #1");
  asm("BIC    R0, R0, R4, %LSL R3");
  asm("STRB   R0, [R8, R1, %LSR #3]");
  asm("MOV    Pc, Link");
No:
  asm("MOV    R3, R1");
  asm("MOV    R1, #14");
  asm("MOV    R2, #3");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Setbits(void) {
  __label__ X1;
  __label__ X2;
  __label__ L1;
  asm("CMPS    R0, R1");
  asm("MOVGT   Pc, Link       {return if inside-out}");
  asm("CMPS    R0, #255");
  asm("BHI     X1");
  asm("CMPS    R1, #255");
  asm("BHI     X2");
  asm("MOV     R4, #1");
L1:
  asm("AND    R3, R1, #7           {bit index into word}");
  asm("LDRB   R5, [R8, R1, %LSR #3]");
  asm("ORR    R5, R5, R4, %LSL R3");
  asm("STRB   R5, [R8, R1, %LSR #3]");
  asm("SUB    R1, R1, #1");
  asm("CMPS   R0, R1");
  asm("BLE    L1");
  asm("MOV    Pc, Link");
X1:
  asm("MOV   R1, R0");
X2:
  asm("MOV   R3, R1");
  asm("MOV   R1, #14");
  asm("MOV   R2, #3");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Clearbits(void) {
  __label__ X1;
  __label__ X2;
  __label__ L1;
  asm("CMPS    R0, R1");
  asm("MOVGT   Pc, Link       {return if inside-out}");
  asm("CMPS    R0, #255");
  asm("BHI     X1");
  asm("CMPS    R1, #255");
  asm("BHI     X2");
  asm("MOV     R4, #1");
L1:
  asm("AND    R3, R1, #7           {bit index into word}");
  asm("LDRB   R5, [R8, R1, %LSR #3]");
  asm("BIC    R5, R5, R4, %LSL R3");
  asm("STRB   R5, [R8, R1, %LSR #3]");
  asm("SUB    R1, R1, #1");
  asm("CMPS   R0, R1");
  asm("BLE    L1");
  asm("MOV    Pc, Link");
X1:
  asm("MOV   R1, R0");
X2:
  asm("MOV   R3, R1");
  asm("MOV   R1, #14");
  asm("MOV   R2, #3");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Setzero(void) {
  asm("LDMIA    R0, <R1,R2,R3,R4,R5,R6,R7,R8>");
  asm("ORRS     R1, R1, R2");
  asm("ORREQS   R1, R3, R4");
  asm("ORREQS   R1, R5, R6");
  asm("ORREQS   R1, R7, R8");
  asm("MOV      Pc, Link");
}
extern void Setequal(void) {
  asm("LDMIA     R0!, <R2,R3,R4,R5>");
  asm("LDMIA     R1!, <R6,R7,R8,R11>");
  asm("CMPS      R2, R6");
  asm("CMPEQS    R3, R7");
  asm("CMPEQS    R4, R8");
  asm("CMPEQS    R5, R11");
  asm("MOVNE     Pc, Link");
  asm("LDMIA     R0!, <R2,R3,R4,R5>");
  asm("LDMIA     R1!, <R6,R7,R8,R11>");
  asm("CMPEQS    R2, R6");
  asm("CMPEQS    R3, R7");
  asm("CMPEQS    R4, R8");
  asm("CMPEQS    R5, R11");
  asm("MOV       Pc, Link");
}
extern void Psym(void) {
  extern int Currentout;
  asm("LDR       R1, Current Out          {address of IMP_CUR_OUT}");
  asm("LDMIA     R1, <R2, R3, R4, R5, R6> {next, limit, handler, Break, "
      "Bhandler}");
  asm("CMPS      R0, R5                   {break character?}");
  asm("MOVLE     Pc, R6                   {yes, use caller's return address}");
  asm("CMPS      R2, R3                   {empty?}");
  asm("MOVGE     Pc, R4                   {flush & add next character}");
  asm("STRB      R0, [R2], #1             {store & increment}");
  asm("STR       R2, [R1]                 {update the pointer}");
  asm("MOV       Pc, Link                 {return}");
}
extern void Realrnd(void) {
  asm("CMF      F0, #0");
  asm("ADFGTE   F0, F0, #1/2 {really 0.5}");
  asm("SUFLTE   F0, F0, #1/2 {really 0.5}");
  asm("FIXEZ    R0, F0");
  asm("MOV      Pc, Link");
}
extern void Realint(void) {
  asm("ADFE    F0, F0, #1/2 {really 0.5}");
  asm("FIXEM    R0, F0");
  asm("MOV     Pc, Link");
}
extern void Realexp(void) {
  __label__ Pl;
  __label__ Nl;
  asm("MVFE   F1, F0");
  asm("MVFE   F0, #1");
  asm("CMPS   R0, #0     {test sign of exponent}");
  asm("BLT   Nl");
Pl:
  asm("MUFGTE   F0, F0, F1   {beware of ^0}");
  asm("SUBS   R0, R0, #1");
  asm("BGT    Pl");
  asm("MOV    Pc, Link");
Nl:
  asm("DVFE   F0, F0, F1");
  asm("ADDS   R0, R0, #1");
  asm("BNE    Nl");
  asm("MOV    Pc, Link");
}
extern void Setrange(void) {
  __label__ L1;
  __label__ L2;
  __label__ No;
  asm("MOV    R3, R1, %lsr #5");
  asm("MOV    R3, R3, %lsl #2");
  asm("AND    R4, R1, #31");
  asm("MVN    R5, #0              {R5=-1}");
  asm("MOV    R5, R5, %lsl R4");
L1:
  asm("LDR    R4, [R0, R3]");
  asm("BICS   R4, R4, R5");
  asm("BNE    No");
  asm("MOV    R5, #0              {R5 = 0}");
  asm("SUBS   R3, R3, #4");
  asm("BGE    L1");
  asm("ADD    R2, R2, #1          {onto first free bit}");
  asm("MOV    R3, R2, %lsr #5");
  asm("MOV    R3, R3, %lsl #2");
  asm("AND    R4, R2, #31");
  asm("MVN    R5, #0");
  asm("MOV    R5, R5, %lsl R4");
L2:
  asm("CMPS   R3, #32");
  asm("MOVGE  Pc, Link            {success}");
  asm("LDR    R4, [R0, R3]");
  asm("ANDS   R4, R4, R5");
  asm("MVNEQ  R5, #0              {R5 = -1}");
  asm("ADDEQ  R3, R3, #4");
  asm("BEQ    L2");
No:
  asm("MOV   R3, #16_80000000");
  asm("MOV   R2, #3");
  asm("MOV   R1, #14");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Range(void) {
  asm("CMPS   R1, R3");
  asm("MOVLS  Pc, Link         {ok if 0 <= R1 <= R3}");
  asm("MOV   R3, R1");
  asm("MOV   R1, #14");
  asm("MOV   R2, #4");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Testnil(void) {
  asm("CMPS    R1, #0");
  asm("MOVGT   Pc, Link");
  asm("MOV   R1, #14");
  asm("MOV   R2, #5");
  asm("MOV   R3, #0");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Testvar(void) {
  asm("CMPS     R3, R1");
  asm("CMPNES   R3, #0");
  asm("MOVEQ    Pc, Link");
  asm("MOV   R1, #14");
  asm("MOV   R2, #6");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Dynrange(void) {
  asm("CMPS     R2, R1");
  asm("CMPLES   R1, R3");
  asm("MOVLE    Pc, Link");
  asm("MOV   R3, R1");
  asm("MOV   R1, #14");
  asm("MOV   R2, #4");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Makelocal(void) {
  __label__ L;
  asm("SUB   Sp, Sp, R0     {claim space}");
  asm("BIC   Sp, Sp, #3     {keep it word aligned}");
  asm("LDR   R3, [R2]       {pointer to source}");
  asm("ADD   R3, R3, R1     {onto first element}");
  asm("SUB   R1, Sp, R1     {onto zero'th address}");
  asm("STR   R1, [R2]       {update pointer}");
  asm("MOV   R1, Sp         {pointer for copying}");
L:
  asm("LDRB  R2, [R3], #1");
  asm("STRB  R2, [R1], #1");
  asm("SUBS  R0, R0, #1");
  asm("BNE   L");
  asm("MOV   Pc, Link");
}
extern void Modulus(void) {
  __label__ No;
  __label__ L0;
  __label__ L1;
  __label__ L2;
  asm("ADDS   R4, R2, #0              {preserve divisor & test it}");
  asm("BLE    No");
L0:
  asm("ADDS     R5, R1, #0            {preserve Dividend & test sign}");
  asm("RSBLT    R1, R1, #0            {R1 = |R1|}");
  asm("MOV      R3, #1");
L1:
  asm("CMPS     R2, #16_80000000");
  asm("CMPCCS   R2, R1");
  asm("MOVCC    R2, R2, %LSL #1");
  asm("MOVCC    R3, R3, %LSL #1");
  asm("BCC      L1");
L2:
  asm("CMPS     R1, R2");
  asm("SUBCS    R1, R1, R2");
  asm("MOVS     R3, R3, %LSR #1");
  asm("MOVNE    R2, R2, %LSR #1");
  asm("BNE      L2");
  asm("CMPS     R5, #0");
  asm("MOVGE    Pc, Link");
  asm("RSBS     R1, R1, #0         {negate remainder}");
  asm("ADDNE    R1, R1, R4         {and add in divisor}");
  asm("MOV      Pc, Link");
No:
  asm("MOV   R1, #14");
  asm("MOV   R2, #7");
  asm("MOV   R3, R4");
  asm("STMDB   Sp!, <R1, R2, R3, Fp, Sb, Link>");
  Callsignal();
}
extern void Genmove(void) {
  __label__ L1;
  __label__ L2;
  __label__ L3;
  __label__ L4;
  asm("ADDS     R3, R3, #0");
  asm("ADDEQS   R3, R4, #0     {Tlen=0 implies Tlen=Flen}");
  asm("MOVLE    Pc, Link       {return if Tlen <= 0}");
  asm("SUBS     R6, R3, R4     {R6 = Tlen - Flen}");
  asm("BGT      L3             {Tlen > Flen}");
L1:
  asm("LDRB   R0, [R2], #1");
  asm("STRB   R0, [R1], #1");
  asm("SUBS   R3, R3, #1");
  asm("BNE    L1");
  asm("MOV    Pc, Link");
L2:
  asm("LDRB   R0, [R2], #1");
  asm("STRB   R0, [R1], #1");
L3:
  asm("SUBS   R4, R4, #1");
  asm("BGE    L2");
  asm("MOV    R0, #32       {space}");
L4:
  asm("STRB   R0, [R1], #1");
  asm("SUBS   R6, R6, #1");
  asm("BNE    L4");
  asm("MOV    Pc, Link");
}
extern void Callp(void) { asm("LDMIA   R4, <R8, Pc>"); }
extern void Enterp(void) { asm("MOV   Pc, R4"); }
extern void Dalloc(void) {
  __label__ L1;
  asm("LDR   R11, [Sb]");
L1:
  asm("STR   R11, [Sp, #-4]!");
  asm("SUBS  R4, R4, #4");
  asm("BGT   L1");
  asm("MOV   Pc, Link");
}