PC Online 1998 November/PCO_1198.ISO/filesbbs/os2/netrexx.arj/NETREXX.ZIP/NetRexx/netrexx/lang/Rexx.class

Java Class File | 1998-09-01 | 32.5 KB | 3,037 lines

package netrexx.lang;

import java.io.Serializable;
import java.util.Enumeration;
import java.util.Hashtable;

public class Rexx implements RexxOperators, Serializable {
   private static final Rexx $01 = new Rexx(0);
   // $FF: renamed from: $0 java.lang.String
   private static final String field_0 = "Rexx.nrx";
   public static final int DefaultDigits = 9;
   public static final byte DefaultForm = 0;
   public static final String Lowers = "abcdefghijklmnopqrstuvwxyz";
   public static final String Uppers = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   public static final String Digits09 = "0123456789";
   public static final char[] Hexes = "0123456789ABCDEFabcdef".toCharArray();
   static final byte ispos = 1;
   static final byte iszero = 0;
   static final byte isneg = -1;
   static final byte NotaNum = -2;
   static final int MinExp = -999999999;
   static final int MaxExp = 999999999;
   static final int MinArg = -999999999;
   static final int MaxArg = 999999999;
   char[] chars;
   byte ind;
   byte form;
   char[] mant;
   int exp;
   int dig;
   Hashtable coll;

   public Rexx(char var1) {
      char[] var2 = new char[]{var1};
      Rexx var3 = new Rexx(var2, true);
      this.chars = var3.chars;
      this.ind = var3.ind;
      this.mant = var3.mant;
      this.exp = var3.exp;
      this.dig = var3.dig;
      this.form = var3.form;
   }

   public Rexx(char[] var1) {
      char[] var2 = new char[var1.length];
      System.arraycopy(var1, 0, var2, 0, var1.length);
      Rexx var3 = new Rexx(var2, true);
      this.chars = var3.chars;
      this.ind = var3.ind;
      this.mant = var3.mant;
      this.exp = var3.exp;
      this.dig = var3.dig;
      this.form = var3.form;
   }

   public Rexx(String var1) {
      this(var1.toCharArray(), true);
   }

   public Rexx(String[] var1) {
      this(sa2ca(var1), true);
   }

   public Rexx(Rexx var1) {
      this.chars = var1.chars;
      this.ind = var1.ind;
      this.mant = var1.mant;
      this.exp = var1.exp;
      this.dig = var1.dig;
      this.form = var1.form;
      this.coll = null;
   }

   public Rexx(boolean var1) {
      this.exp = 0;
      this.dig = 9;
      this.form = 0;
      this.mant = new char[1];
      if (var1) {
         this.mant[0] = '1';
         this.ind = 1;
      } else {
         this.mant[0] = '0';
         this.ind = 0;
      }

      this.chars = this.mant;
   }

   public Rexx(byte var1) {
      this((int)var1);
   }

   public Rexx(short var1) {
      this((int)var1);
   }

   public Rexx(int var1) {
      this.exp = 0;
      this.form = 0;
      if (var1 <= 9 && var1 >= -9) {
         this.mant = new char[1];
         if (var1 > 0) {
            this.mant[0] = (char)(48 + var1);
            this.chars = this.mant;
            this.ind = 1;
         } else if (var1 == 0) {
            this.mant[0] = '0';
            this.chars = this.mant;
            this.ind = 0;
         } else {
            this.chars = new char[2];
            this.chars[0] = '-';
            this.chars[1] = (char)(48 - var1);
            this.mant[0] = this.chars[1];
            this.ind = -1;
         }
      } else if (var1 > 0) {
         this.ind = 1;
         this.mant = Integer.toString(var1, 10).toCharArray();
         this.chars = this.mant;
      } else {
         this.ind = -1;
         this.chars = null;
         this.dig = 10;
         if (var1 == Integer.MIN_VALUE) {
            this.mant = (new String("2147483648")).toCharArray();
         } else {
            var1 = -var1;
            this.mant = Integer.toString(var1, 10).toCharArray();
         }
      }
   }

   public Rexx(long var1) {
      this(String.valueOf(var1).toCharArray(), true);
   }

   public Rexx(float var1) {
      this(RexxUtil.doubleToRexx((double)var1, 7));
   }

   public Rexx(double var1) {
      this(RexxUtil.doubleToRexx(var1, 16));
   }

   Rexx(char[] var1, boolean var2) {
      boolean var4 = false;
      boolean var11 = false;
      byte var12 = 0;
      int var13 = 0;
      char var14 = '\u0000';
      this.chars = var1;
      this.ind = -2;
      if (var1.length != 0) {
         if (var1[0] > '9') {
            if (var1[0] <= 127) {
               return;
            }

            if (!Character.isDigit(var1[0])) {
               return;
            }
         }

         if (var2) {
            int var3 = var1.length;

            for(int var19 = var3 - 1; var19 >= 0 && var1[var19] == ' '; --var19) {
               --var3;
               if (var3 == 0) {
                  return;
               }
            }

            byte var5 = 0;
            int var6 = -1;
            int var15 = var3 - 1;

            for(int var20 = 0; var20 <= var15; ++var20) {
               if (var1[var20] != ' ') {
                  if (var1[var20] == '-') {
                     if (var5 != 0) {
                        return;
                     }

                     var5 = -1;
                  } else {
                     if (var1[var20] != '+') {
                        var6 = var20;
                        break;
                     }

                     if (var5 != 0) {
                        return;
                     }

                     var5 = 1;
                  }
               }
            }

            if (var6 >= 0) {
               boolean var7 = false;
               int var8 = 0;
               int var9 = -1;
               int var10 = -1;
               int var16 = var3 - 1;

               for(int var21 = var6; var21 <= var16; ++var21) {
                  if (var1[var21] >= '0' && var1[var21] <= '9') {
                     var10 = var21;
                     ++var8;
                  } else if (var1[var21] == '.') {
                     if (var9 >= 0) {
                        return;
                     }

                     var9 = var21 - var6;
                  } else {
                     if (var1[var21] == 'e' || var1[var21] == 'E') {
                        if (var21 > var3 - 3) {
                           return;
                        }

                        if (var3 - var21 > 11) {
                           return;
                        }

                        if (var1[var21 + 1] == '-') {
                           var11 = true;
                        } else {
                           if (var1[var21 + 1] != '+') {
                              return;
                           }

                           var11 = false;
                        }

                        if (var3 - var21 - 2 > 9) {
                           return;
                        }

                        int var17 = var3 - 1;

                        for(int var26 = var21 + 2; var26 <= var17; ++var26) {
                           if (var1[var26] < '0') {
                              return;
                           }

                           if (var1[var26] > '9') {
                              if (!Character.isDigit(var1[var26])) {
                                 return;
                              }

                              var13 = Character.digit(var1[var26], 10);
                              if (var13 < 0) {
                                 return;
                              }
                           } else {
                              var13 = var1[var26] - 48;
                           }

                           this.exp = this.exp * 10 + var13;
                        }

                        if (var11) {
                           this.exp = -this.exp;
                        }
                        break;
                     }

                     if (!Character.isDigit(var1[var21])) {
                        return;
                     }

                     var7 = true;
                     var10 = var21;
                     ++var8;
                  }
               }

               if (var8 != 0) {
                  if (var9 >= 0) {
                     this.exp = this.exp + var9 - var8;
                  }

                  int var32 = var10 - 1;

                  for(int var22 = var6; var22 <= var32; ++var22) {
                     if (var1[var22] == '.') {
                        ++var6;
                     } else if (var1[var22] == '0') {
                        ++var6;
                        --var8;
                     } else {
                        if (var1[var22] <= '9' || Character.digit(var1[var22], 10) != 0) {
                           break;
                        }

                        ++var6;
                        --var8;
                     }
                  }

                  if (var7) {
                     this.mant = new char[var8];
                     var12 = 0;
                     int var18 = var8 - 1;

                     for(int var23 = 0; var23 <= var18; ++var23) {
                        if (var1[var6 + var23] == '.') {
                           var12 = 1;
                        }

                        var14 = var1[var6 + var23 + var12];
                        if (var14 <= '9') {
                           this.mant[var23] = var14;
                        } else {
                           var13 = Character.digit(var14, 10);
                           if (var13 < 0) {
                              return;
                           }

                           this.mant[var23] = (char)(var13 + 48);
                        }
                     }
                  } else if (var8 == this.chars.length) {
                     this.mant = this.chars;
                  } else {
                     this.mant = new char[var8];
                     var12 = 0;
                     int var33 = var8 - 1;

                     for(int var24 = 0; var24 <= var33; ++var24) {
                        if (var1[var6 + var24] == '.') {
                           var12 = 1;
                        }

                        this.mant[var24] = var1[var6 + var24 + var12];
                     }
                  }

                  if (this.mant[0] == '0') {
                     this.ind = 0;
                     this.exp = 0;
                  } else if (var5 < 0) {
                     this.ind = -1;
                  } else {
                     this.ind = 1;
                  }
               }
            }
         }
      }
   }

   Rexx() {
   }

   public RexxNode getnode(Rexx var1) {
      if (this.coll == null) {
         synchronized(this){}

         try {
            if (this.coll == null) {
               this.coll = new Hashtable(37, 0.67F);
            }
         } catch (Throwable var5) {
            throw var5;
         }
      }

      RexxNode var2 = (RexxNode)this.coll.get(var1);
      if (var2 != null && var2.leaf != null) {
         return var2;
      } else {
         var2 = new RexxNode(new Rexx(this));
         this.coll.put(var1, var2);
         return var2;
      }
   }

   public boolean testnode(Rexx var1) {
      if (this.coll == null) {
         return false;
      } else {
         RexxNode var2 = (RexxNode)this.coll.get(var1);
         if (var2 == null) {
            return false;
         } else if (var2.leaf == null) {
            return false;
         } else {
            return var2.leaf != var2.initleaf;
         }
      }
   }

   public synchronized Enumeration keys() {
      if (this.coll == null) {
         synchronized(this){}

         try {
            if (this.coll == null) {
               this.coll = new Hashtable(37, 0.67F);
            }
         } catch (Throwable var3) {
            throw var3;
         }
      }

      return this.coll.keys();
   }

   private final int intlength() {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return this.chars.length;
   }

   private final int intwords() {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return RexxWords.words(this.chars);
   }

   public String toString() {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return new String(this.chars);
   }

   public char[] toCharArray() {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      char[] var1 = new char[this.chars.length];
      System.arraycopy(this.chars, 0, var1, 0, this.chars.length);
      return var1;
   }

   public char tochar() throws NotCharacterException {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (this.chars.length != 1) {
         throw new NotCharacterException(String.valueOf(this.chars));
      } else {
         return this.chars[0];
      }
   }

   public int hashCode() {
      int var1 = 0;
      boolean var3 = false;
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (this.chars.length < 14) {
         var1 = (this.chars.length + 1) / 2;
      } else {
         var1 = 7;
      }

      int var2 = 0;
      int var4 = var1 - 1;

      for(int var6 = 0; var6 <= var4; ++var6) {
         var2 = var2 * 7 + this.chars[var6] * 2 + this.chars[this.chars.length - var6 - 1];
      }

      return var2;
   }

   public boolean equals(Object var1) {
      if (var1 == null) {
         return false;
      } else if (var1 instanceof Rexx) {
         return this.docomparestrict((RexxSet)null, (Rexx)var1) == 0;
      } else if (var1 instanceof String) {
         return this.docomparestrict((RexxSet)null, new Rexx((String)var1)) == 0;
      } else if (var1 instanceof char[]) {
         return this.docomparestrict((RexxSet)null, new Rexx((char[])var1)) == 0;
      } else {
         return false;
      }
   }

   public char charAt(int var1) {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return this.chars[var1];
   }

   public static char tochar(String var0) throws NotCharacterException {
      if (var0.length() != 1) {
         throw new NotCharacterException(var0);
      } else {
         return var0.charAt(0);
      }
   }

   public static char tochar(char[] var0) throws NotCharacterException {
      if (var0.length != 1) {
         throw new NotCharacterException(String.valueOf(var0));
      } else {
         return var0[0];
      }
   }

   public static char[] tochararray(char var0) {
      char[] var1 = new char[]{var0};
      return var1;
   }

   public static final char[] tochararray(Rexx var0) {
      if (var0 == null) {
         return null;
      } else {
         if (var0.chars == null) {
            var0.chars = var0.layout();
         }

         char[] var1 = new char[var0.chars.length];
         System.arraycopy(var0.chars, 0, var1, 0, var0.chars.length);
         return var1;
      }
   }

   public static final Rexx toRexx(char[] var0) {
      if (var0 == null) {
         return null;
      } else {
         char[] var1 = new char[var0.length];
         System.arraycopy(var0, 0, var1, 0, var0.length);
         return new Rexx(var1, true);
      }
   }

   public static final Rexx toRexx(String var0) {
      return var0 == null ? null : new Rexx(var0.toCharArray(), true);
   }

   public static final String toString(Rexx var0) {
      if (var0 == null) {
         return null;
      } else {
         if (var0.chars == null) {
            var0.chars = var0.layout();
         }

         return new String(var0.chars);
      }
   }

   public int significance() {
      return this.ind == -2 ? 0 : this.mant.length;
   }

   public boolean toboolean() throws NotLogicException {
      if (this.ind == 0) {
         return false;
      } else if (this.ind == 1 && this.mant.length == 1 && this.mant[0] == '1') {
         return true;
      } else {
         throw new NotLogicException("Boolean must be 0 or 1.  Found: " + this.toString());
      }
   }

   public byte tobyte() throws NumberFormatException {
      int var1 = this.toint();
      if (var1 > 127 | var1 < -128) {
         throw new NumberFormatException("Conversion overflow");
      } else {
         return (byte)var1;
      }
   }

   public short toshort() throws NumberFormatException {
      int var1 = this.toint();
      if (var1 > 32767 | var1 < -32768) {
         throw new NumberFormatException("Conversion overflow");
      } else {
         return (short)var1;
      }
   }

   public int toint() throws NumberFormatException {
      int var2 = 0;
      boolean var3 = false;
      int var4 = 0;
      boolean var7 = false;
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else if (this.ind == 0) {
         return 0;
      } else {
         int var1 = this.mant.length - 1;
         if (this.exp < 0) {
            var1 += this.exp;
            if (var1 < 0) {
               var2 = 0;
            } else {
               var2 = var1 + 1;
            }

            int var8 = this.mant.length - 1;

            for(int var10 = var2; var10 <= var8; ++var10) {
               if (this.mant[var10] != '0') {
                  throw new NumberFormatException(toString(toRexx("Decimal part non-zero:").OpCcblank((RexxSet)null, this)));
               }
            }

            if (var1 < 0) {
               return 0;
            }

            var4 = 0;
         } else {
            if (this.exp + this.mant.length > 10) {
               throw new NumberFormatException("Conversion overflow");
            }

            var4 = this.exp;
         }

         int var5 = 0;
         int var6 = var5;
         int var13 = var1 + var4;

         for(int var12 = 0; var12 <= var13; ++var12) {
            var5 *= 10;
            if (var12 <= var1) {
               var5 += this.mant[var12] - 48;
            }

            if (var5 < var6) {
               if (this.ind == -1 && var5 == Integer.MIN_VALUE && var12 == var1 + var4) {
                  return var5;
               }

               throw new NumberFormatException("Conversion overflow");
            }

            var6 = var5;
         }

         if (this.ind > 0) {
            return var5;
         } else {
            return -var5;
         }
      }
   }

   public long tolong() throws NumberFormatException {
      int var2 = 0;
      boolean var3 = false;
      int var4 = 0;
      boolean var9 = false;
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else if (this.ind == 0) {
         return 0L;
      } else {
         int var1 = this.mant.length - 1;
         if (this.exp < 0) {
            var1 += this.exp;
            if (var1 < 0) {
               var2 = 0;
            } else {
               var2 = var1 + 1;
            }

            int var10 = this.mant.length - 1;

            for(int var12 = var2; var12 <= var10; ++var12) {
               if (this.mant[var12] != '0') {
                  throw new NumberFormatException(toString(toRexx("Decimal part non-zero:").OpCcblank((RexxSet)null, this)));
               }
            }

            if (var1 < 0) {
               return 0L;
            }

            var4 = 0;
         } else {
            if (this.exp + this.mant.length >= 20) {
               throw new NumberFormatException("Conversion overflow");
            }

            var4 = this.exp;
         }

         long var5 = 0L;
         long var7 = var5;
         int var15 = var1 + var4;

         for(int var14 = 0; var14 <= var15; ++var14) {
            var5 *= 10L;
            if (var14 <= var1) {
               var5 += (long)(this.mant[var14] - 48);
            }

            if (var5 < var7) {
               if (this.ind < 0 && var5 == Long.MIN_VALUE && var14 == var1 + var4) {
                  return var5;
               }

               throw new NumberFormatException("Conversion overflow");
            }

            var7 = var5;
         }

         if (this.ind > 0) {
            return var5;
         } else {
            return -var5;
         }
      }
   }

   public float tofloat() throws NumberFormatException {
      double var1 = this.todouble();
      if (var1 > 3.402823466E38 | var1 < -3.402823466E38) {
         throw new NumberFormatException("Overflow");
      } else {
         return (float)var1;
      }
   }

   public double todouble() throws NumberFormatException {
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else {
         if (this.chars == null) {
            this.chars = this.layout();
         }

         double var1 = Double.valueOf(new String(this.chars));
         if (Double.isInfinite(var1)) {
            throw new NumberFormatException("Overflow");
         } else {
            return var1;
         }
      }
   }

   char[] layoutnum() {
      return this.layout();
   }

   private char[] layout() {
      Object var2 = null;
      int var3 = 0;
      int var4 = 0;
      Object var5 = null;
      Object var6 = null;
      if (this.ind == -2) {
         RexxIO.Say("Internal error: Rexx missing number " + String.valueOf(this.chars));
      }

      if (this.dig < 0) {
         RexxIO.Say("Internal error: Rexx: bad dig " + String.valueOf(this.dig));
         this.dig = 9;
      }

      int var1 = this.exp + this.mant.length;
      if (var1 > this.dig | var1 < -5) {
         StringBuffer var9 = new StringBuffer(this.mant.length + 15);
         if (this.ind == -1) {
            var9.append('-');
         }

         var3 = this.exp + this.mant.length - 1;
         if (this.form == 0) {
            var9.append(this.mant[0]);
            if (this.mant.length > 1) {
               var9.append('.').append(this.mant, 1, this.mant.length - 1);
            }
         } else {
            var4 = var3 % 3;
            if (var4 < 0) {
               var4 += 3;
            }

            var3 -= var4;
            ++var4;
            if (var4 >= this.mant.length) {
               var9.append(this.mant, 0, this.mant.length);

               for(int var20 = var4 - this.mant.length; var20 > 0; --var20) {
                  var9.append('0');
               }
            } else {
               var9.append(this.mant, 0, var4).append('.').append(this.mant, var4, this.mant.length - var4);
            }
         }

         if (var3 != 0) {
            String var13;
            if (var3 < 0) {
               var13 = "-";
               var3 = -var3;
            } else {
               var13 = "+";
            }

            var9.append('E').append(var13).append(var3);
         }

         char[] var18 = new char[var9.length()];
         var9.getChars(0, var9.length(), var18, 0);
         return var18;
      } else if (this.exp == 0) {
         if (this.ind >= 0) {
            return this.mant;
         } else {
            char[] var17 = new char[this.mant.length + 1];
            var17[0] = '-';
            System.arraycopy(this.mant, 0, var17, 1, this.mant.length);
            return var17;
         }
      } else {
         StringBuffer var8 = new StringBuffer(this.mant.length + this.dig + 5 + 3 + 10);
         if (this.ind == -1) {
            var8.append('-');
         }

         if (var1 < 1) {
            var8.append('0').append('.');

            for(int var19 = -var1; var19 > 0; --var19) {
               var8.append('0');
            }

            var8.append(this.mant);
            char[] var16 = new char[var8.length()];
            var8.getChars(0, var8.length(), var16, 0);
            return var16;
         } else if (var1 <= this.mant.length) {
            var8.append(this.mant, 0, var1).append('.').append(this.mant, var1, this.mant.length - var1);
            char[] var15 = new char[var8.length()];
            var8.getChars(0, var8.length(), var15, 0);
            return var15;
         } else {
            var8.append(this.mant);

            for(int var7 = var1 - this.mant.length; var7 > 0; --var7) {
               var8.append('0');
            }

            char[] var14 = new char[var8.length()];
            var8.getChars(0, var8.length(), var14, 0);
            return var14;
         }
      }
   }

   private char padcheck() throws NotCharacterException {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (this.chars.length != 1) {
         throw new NotCharacterException(String.valueOf(this.chars));
      } else {
         return this.chars[0];
      }
   }

   private int intcheck(int var1, int var2) throws BadArgumentException {
      int var4 = 0;
      if (this.ind == -2) {
         throw new NumberFormatException("Not a number");
      } else {
         int var3 = this.mant.length - 1;
         if (this.exp < 0) {
            for(int var5 = this.exp + 1; var5 <= 0; ++var5) {
               if (this.mant[var3] != '0') {
                  throw new NumberFormatException(toString(toRexx("Non-zero decimal part in").OpCcblank((RexxSet)null, this)));
               }

               --var3;
            }
         }

         var4 = this.toint();
         if (var4 < var1) {
            throw new BadArgumentException("Argument " + String.valueOf(var4) + " " + "<" + " " + var1);
         } else if (var4 > var2) {
            throw new BadArgumentException("Argument " + String.valueOf(var4) + " " + ">" + " " + var2);
         } else {
            return var4;
         }
      }
   }

   private char optioncheck(String var1) throws BadArgumentException {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (this.chars.length == 0) {
         throw new BadArgumentException("Null option string");
      } else {
         char var2 = this.chars[0];
         char var3 = Character.toUpperCase(var2);
         if (var1.indexOf(var3, 0) < 0) {
            throw new BadArgumentException("Bad Option character " + String.valueOf(var2) + " " + "[" + var3 + "]");
         } else {
            return var3;
         }
      }
   }

   public Rexx abbrev(Rexx var1) {
      return this.abbrev(var1, new Rexx(var1.intlength()));
   }

   public Rexx abbrev(Rexx var1, Rexx var2) {
      int var3 = var2.intcheck(0, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (var1.chars == null) {
         var1.chars = var1.layout();
      }

      return new Rexx(RexxWords.abbrev(this.chars, var1.chars, var3));
   }

   public Rexx abs() throws NumberFormatException {
      Object var1 = null;
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else {
         RexxSet var2;
         if (this.mant.length > 9) {
            var2 = new RexxSet(this.mant.length);
         } else {
            var2 = null;
         }

         return this.ind >= 0 ? this.OpPlus(var2) : this.OpMinus(var2);
      }
   }

   public Rexx b2x() {
      boolean var5 = false;
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (this.chars.length == 0) {
         throw new BadArgumentException("No digits");
      } else {
         char[] var1 = new char[(this.chars.length + 3) / 4];
         int var2 = var1.length - 1;
         int var3 = 0;
         int var4 = 1;

         for(int var6 = this.chars.length - 1; var6 >= 0; --var6) {
            if (this.chars[var6] != '0') {
               if (this.chars[var6] != '1') {
                  throw new BadArgumentException(toString(toRexx("Bad binary").OpCcblank((RexxSet)null, this)));
               }

               var3 += var4;
            }

            var4 += var4;
            if (var4 == 16 | var6 == 0) {
               var1[var2] = Hexes[var3];
               --var2;
               var3 = 0;
               var4 = 1;
            }
         }

         return new Rexx(var1);
      }
   }

   public Rexx centre(Rexx var1) {
      return this.centre(var1, toRexx(" "));
   }

   public Rexx centre(Rexx var1, Rexx var2) {
      int var3 = var1.intcheck(0, 999999999);
      char var4 = var2.padcheck();
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return toRexx(RexxWords.centre(this.chars, var3, var4));
   }

   public Rexx center(Rexx var1) {
      return this.center(var1, toRexx(" "));
   }

   public Rexx center(Rexx var1, Rexx var2) {
      return this.centre(var1, var2);
   }

   public Rexx changestr(Rexx var1, Rexx var2) {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (var1.chars == null) {
         var1.chars = var1.layout();
      }

      if (var2.chars == null) {
         var2.chars = var2.layout();
      }

      return toRexx(RexxWords.changestr(var1.chars, this.chars, var2.chars));
   }

   public Rexx compare(Rexx var1) {
      return this.compare(var1, toRexx(" "));
   }

   public Rexx compare(Rexx var1, Rexx var2) {
      char var3 = var2.padcheck();
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (var1.chars == null) {
         var1.chars = var1.layout();
      }

      return new Rexx(RexxWords.compare(this.chars, var1.chars, var3));
   }

   public Rexx copies(Rexx var1) throws BadArgumentException {
      int var2 = var1.intcheck(0, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      int var3 = this.chars.length;
      char[] var4 = new char[var2 * var3];
      int var5 = 0;

      for(int var6 = var2; var6 > 0; --var6) {
         System.arraycopy(this.chars, 0, var4, var5, var3);
         var5 += var3;
      }

      return new Rexx(var4, true);
   }

   public synchronized Rexx copyIndexed(Rexx var1) {
      Object var2 = null;
      Object var3 = null;
      Object var4 = null;
      if (var1.coll == null) {
         return this;
      } else {
         Hashtable var5 = var1.coll;
         synchronized(var5){}

         try {
            Enumeration var8 = var1.coll.keys();

            while(var8.hasMoreElements()) {
               Rexx var9 = (Rexx)var8.nextElement();
               RexxNode var10 = (RexxNode)var1.coll.get(var9);
               if (var10.leaf != null && var10.leaf != var10.initleaf) {
                  this.getnode(var9).leaf = var10.leaf;
               }
            }
         } catch (Throwable var7) {
            throw var7;
         }

         return this;
      }
   }

   public Rexx countstr(Rexx var1) {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (var1.chars == null) {
         var1.chars = var1.layout();
      }

      return new Rexx(RexxWords.countstr(var1.chars, this.chars));
   }

   public Rexx c2d() {
      return new Rexx(this.padcheck());
   }

   public Rexx c2x() {
      int var1 = this.padcheck();
      char[] var2 = "0000".toCharArray();
      var2[3] = Hexes[var1 % 16];
      var1 /= 16;
      if (var1 == 0) {
         return (new Rexx(var2)).right(new Rexx(1));
      } else {
         var2[2] = Hexes[var1 % 16];
         var1 /= 16;
         if (var1 == 0) {
            return (new Rexx(var2)).right(new Rexx(2));
         } else {
            var2[1] = Hexes[var1 % 16];
            var1 /= 16;
            if (var1 == 0) {
               return (new Rexx(var2)).right(new Rexx(3));
            } else {
               var2[0] = Hexes[var1 % 16];
               var1 /= 16;
               return new Rexx(var2);
            }
         }
      }
   }

   public Rexx datatype(Rexx var1) throws BadArgumentException {
      int var3 = 0;
      Object var4 = null;
      char var2 = var1.optioncheck("ABDLMNSUWX");
      if (this.intlength() == 0) {
         var3 = 0;
      } else if (var2 == 'A') {
         var3 = this.verify(toRexx("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")).OpEqS((RexxSet)null, $01) ? 1 : 0;
      } else if (var2 == 'B') {
         var3 = this.verify(toRexx("01")).OpEqS((RexxSet)null, $01) ? 1 : 0;
      } else if (var2 == 'D') {
         var3 = this.verify(toRexx("0123456789")).OpEqS((RexxSet)null, $01) ? 1 : 0;
      } else if (var2 == 'L') {
         var3 = this.verify(toRexx("abcdefghijklmnopqrstuvwxyz")).OpEqS((RexxSet)null, $01) ? 1 : 0;
      } else if (var2 == 'M') {
         var3 = this.verify(toRexx("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")).OpEqS((RexxSet)null, $01) ? 1 : 0;
      } else if (var2 == 'N') {
         var3 = this.ind != -2 ? 1 : 0;
      } else if (var2 == 'S') {
         var3 = this.verify(toRexx("_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")).OpEqS((RexxSet)null, $01) & this.left(new Rexx(1)).verify(toRexx("0123456789")).OpNotEqS((RexxSet)null, $01) ? 1 : 0;
      } else if (var2 == 'U') {
         var3 = this.verify(toRexx("ABCDEFGHIJKLMNOPQRSTUVWXYZ")).OpEqS((RexxSet)null, $01) ? 1 : 0;
      } else if (var2 == 'W') {
         if (this.ind == -2) {
            var3 = 0;
         } else {
            RexxSet var6;
            if (this.mant.length > 9) {
               var6 = new RexxSet(this.mant.length);
            } else {
               var6 = null;
            }

            var3 = this.OpDiv(var6, new Rexx('1')).pos(new Rexx('.')).OpEqS((RexxSet)null, $01) ? 1 : 0;
         }
      } else {
         if (var2 != 'X') {
            throw new NoOtherwiseException();
         }

         var3 = this.verify(toRexx(Hexes)).OpEqS((RexxSet)null, $01) ? 1 : 0;
      }

      return new Rexx(var3);
   }

   public Rexx delstr(Rexx var1) throws BadArgumentException {
      return this.delstr(var1, new Rexx(this.intlength()));
   }

   public Rexx delstr(Rexx var1, Rexx var2) throws BadArgumentException {
      int var3 = var1.intcheck(1, 999999999);
      int var4 = var2.intcheck(0, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return toRexx(RexxWords.delstr(this.chars, var3, var4));
   }

   public Rexx delword(Rexx var1) throws BadArgumentException {
      return this.delword(var1, new Rexx(this.intwords()));
   }

   public Rexx delword(Rexx var1, Rexx var2) throws BadArgumentException {
      int var3 = var1.intcheck(1, 999999999);
      int var4 = var2.intcheck(0, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return toRexx(RexxWords.delword(this.chars, var3, var4));
   }

   public Rexx d2c() {
      int var1 = this.toint();
      if (var1 < 0 | var1 > 65535) {
         throw new NumberFormatException(toString(toRexx("Encoding bad").OpCcblank((RexxSet)null, this)));
      } else {
         return new Rexx((char)var1);
      }
   }

   public Rexx d2x(Rexx var1) throws BadArgumentException, NumberFormatException {
      int var2 = var1.intcheck(0, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return toRexx(RexxUtil.d2x(this, var2));
   }

   public Rexx d2x() throws BadArgumentException, NumberFormatException {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return toRexx(RexxUtil.d2x(this, -1));
   }

   public Rexx exists(Rexx var1) {
      return new Rexx(this.testnode(var1));
   }

   public Rexx format() throws BadArgumentException, NumberFormatException {
      return this.format((Rexx)null, (Rexx)null, (Rexx)null, (Rexx)null, (Rexx)null);
   }

   public Rexx format(Rexx var1) throws BadArgumentException, NumberFormatException {
      return this.format(var1, (Rexx)null, (Rexx)null, (Rexx)null, (Rexx)null);
   }

   public Rexx format(Rexx var1, Rexx var2) throws BadArgumentException, NumberFormatException {
      return this.format(var1, var2, (Rexx)null, (Rexx)null, (Rexx)null);
   }

   public Rexx format(Rexx var1, Rexx var2, Rexx var3) throws BadArgumentException, NumberFormatException {
      return this.format(var1, var2, var3, (Rexx)null, (Rexx)null);
   }

   public Rexx format(Rexx var1, Rexx var2, Rexx var3, Rexx var4) throws BadArgumentException, NumberFormatException {
      return this.format(var1, var2, var3, var4, (Rexx)null);
   }

   public Rexx format(Rexx var1, Rexx var2, Rexx var3, Rexx var4, Rexx var5) throws BadArgumentException, NumberFormatException {
      int var6 = 0;
      int var7 = 0;
      int var8 = 0;
      int var9 = 0;
      Object var10 = null;
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else {
         if (var1 == null) {
            var6 = -1;
         } else {
            var6 = var1.intcheck(1, 999999999);
         }

         if (var2 == null) {
            var7 = -1;
         } else {
            var7 = var2.intcheck(0, 999999999);
         }

         if (var3 == null) {
            var8 = -1;
         } else {
            var8 = var3.intcheck(1, 999999999);
         }

         if (var4 == null) {
            var9 = -1;
         } else {
            var9 = var4.intcheck(0, 999999999);
         }

         String var15;
         if (var5 == null) {
            var15 = "S";
         } else {
            var15 = String.valueOf(var5.optioncheck("SE"));
         }

         return new Rexx(RexxUtil.format(this, var6, var7, var8, var9, tochar(var15)), true);
      }
   }

   public Rexx insert(Rexx var1) throws BadArgumentException {
      return this.insert(var1, new Rexx(0), new Rexx(var1.intlength()), toRexx(" "));
   }

   public Rexx insert(Rexx var1, Rexx var2) throws BadArgumentException {
      return this.insert(var1, var2, new Rexx(var1.intlength()), toRexx(" "));
   }

   public Rexx insert(Rexx var1, Rexx var2, Rexx var3) throws BadArgumentException {
      return this.insert(var1, var2, var3, toRexx(" "));
   }

   public Rexx insert(Rexx var1, Rexx var2, Rexx var3, Rexx var4) throws BadArgumentException {
      int var5 = var2.intcheck(0, 999999999);
      int var6 = var3.intcheck(0, 999999999);
      char var7 = var4.padcheck();
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (var1.chars == null) {
         var1.chars = var1.layout();
      }

      return new Rexx(RexxWords.insert(this.chars, var1.chars, var5, var6, var7), true);
   }

   public Rexx lastpos(Rexx var1) throws BadArgumentException {
      int var2 = this.intlength();
      if (var2 == 0) {
         var2 = 1;
      }

      return this.lastpos(var1, new Rexx(var2));
   }

   public Rexx lastpos(Rexx var1, Rexx var2) throws BadArgumentException {
      boolean var5 = false;
      boolean var6 = false;
      int var3 = var2.intcheck(1, 999999999) - 1;
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (var3 >= this.chars.length) {
         var3 = this.chars.length - 1;
      }

      if (var1.chars == null) {
         var1.chars = var1.layout();
      }

      int var4 = var1.chars.length;
      if (var4 == 0) {
         return new Rexx(0);
      } else {
         var3 = var3 - var4 + 1;

         label40:
         for(int var9 = var3; var9 >= 0; --var9) {
            int var7 = var4 - 1;

            for(int var10 = 0; var10 <= var7; ++var10) {
               if (var1.chars[var10] != this.chars[var9 + var10]) {
                  continue label40;
               }
            }

            return new Rexx(var9 + 1);
         }

         return new Rexx(0);
      }
   }

   public Rexx left(Rexx var1) {
      return this.left(var1, toRexx(" "));
   }

   public Rexx left(Rexx var1, Rexx var2) {
      return this.substr(new Rexx(1), var1, var2);
   }

   public Rexx length() {
      return new Rexx(this.intlength());
   }

   public Rexx lower() throws BadArgumentException {
      return this.lower(new Rexx(1), this.length());
   }

   public Rexx lower(Rexx var1) throws BadArgumentException {
      return this.lower(var1, this.length());
   }

   public Rexx lower(Rexx var1, Rexx var2) throws BadArgumentException {
      boolean var7 = false;
      int var3 = var1.intcheck(1, 999999999) - 1;
      int var4 = var2.intcheck(0, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      int var5 = this.chars.length;
      if (var5 == 0) {
         return new Rexx("");
      } else {
         char[] var6 = new char[var5];
         if (var4 < var5 | var3 > 0) {
            System.arraycopy(this.chars, 0, var6, 0, var5);
         }

         int var8 = var5 - 1;
         int var9 = var4;

         for(int var10 = var3; var10 <= var8 && var9 > 0; ++var10) {
            var6[var10] = Character.toLowerCase(this.chars[var10]);
            --var9;
         }

         return new Rexx(var6, true);
      }
   }

   public Rexx max(Rexx var1) throws NumberFormatException {
      Rexx var3 = null;
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else if (var1.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else {
         int var2 = 9;
         if (this.mant.length > var2) {
            var2 = this.mant.length;
         }

         if (var1.mant.length > var2) {
            var2 = var1.mant.length;
         }

         if (this.docompare(new RexxSet(var2), var1) < 0) {
            var3 = var1;
         } else {
            var3 = this;
         }

         var2 = 9;
         if (var3.mant.length > var2) {
            var2 = var3.mant.length;
         }

         return var3.OpPlus(new RexxSet(var2));
      }
   }

   public Rexx min(Rexx var1) throws NumberFormatException {
      Rexx var3 = null;
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else if (var1.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else {
         int var2 = 9;
         if (this.mant.length > var2) {
            var2 = this.mant.length;
         }

         if (var1.mant.length > var2) {
            var2 = var1.mant.length;
         }

         if (this.docompare(new RexxSet(var2), var1) > 0) {
            var3 = var1;
         } else {
            var3 = this;
         }

         var2 = 9;
         if (var3.mant.length > var2) {
            var2 = var3.mant.length;
         }

         return var3.OpPlus(new RexxSet(var2));
      }
   }

   public Rexx overlay(Rexx var1) throws BadArgumentException {
      return this.overlay(var1, new Rexx(1), new Rexx(var1.intlength()), toRexx(" "));
   }

   public Rexx overlay(Rexx var1, Rexx var2) throws BadArgumentException {
      return this.overlay(var1, var2, new Rexx(var1.intlength()), toRexx(" "));
   }

   public Rexx overlay(Rexx var1, Rexx var2, Rexx var3) throws BadArgumentException {
      return this.overlay(var1, var2, var3, toRexx(" "));
   }

   public Rexx overlay(Rexx var1, Rexx var2, Rexx var3, Rexx var4) throws BadArgumentException {
      int var5 = var2.intcheck(1, 999999999);
      int var6 = var3.intcheck(0, 999999999);
      char var7 = var4.padcheck();
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (var1.chars == null) {
         var1.chars = var1.layout();
      }

      return new Rexx(RexxWords.overlay(this.chars, var1.chars, var5, var6, var7), true);
   }

   public Rexx pos(Rexx var1) throws BadArgumentException {
      return this.pos(var1, new Rexx(1));
   }

   public Rexx pos(Rexx var1, Rexx var2) throws BadArgumentException {
      boolean var4 = false;
      boolean var5 = false;
      int var3 = var2.intcheck(1, 999999999) - 1;
      if (var1.chars == null) {
         var1.chars = var1.layout();
      }

      if (var1.chars.length == 0) {
         return new Rexx(0);
      } else {
         if (this.chars == null) {
            this.chars = this.layout();
         }

         int var6 = this.chars.length - var1.chars.length;

         label36:
         for(int var8 = var3; var8 <= var6; ++var8) {
            int var7 = var1.chars.length - 1;

            for(int var9 = 0; var9 <= var7; ++var9) {
               if (var1.chars[var9] != this.chars[var8 + var9]) {
                  continue label36;
               }
            }

            return new Rexx(var8 + 1);
         }

         return new Rexx(0);
      }
   }

   public Rexx reverse() {
      boolean var3 = false;
      if (this.chars == null) {
         this.chars = this.layout();
      }

      int var1 = this.chars.length;
      if (var1 == 0) {
         return new Rexx("");
      } else {
         char[] var2 = new char[var1];
         int var4 = var1 - 1;

         for(int var5 = 0; var5 <= var4; ++var5) {
            --var1;
            var2[var5] = this.chars[var1];
         }

         return new Rexx(var2, true);
      }
   }

   public Rexx right(Rexx var1) throws NotCharacterException, BadArgumentException {
      return this.right(var1, toRexx(" "));
   }

   public Rexx right(Rexx var1, Rexx var2) throws NotCharacterException, BadArgumentException {
      int var7 = 0;
      int var3 = var1.intcheck(0, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      int var4 = this.chars.length - var3;
      if (var4 >= 0) {
         return this.substr(new Rexx(var4 + 1));
      } else {
         char var5 = var2.padcheck();
         char[] var6 = new char[var3];
         int var8 = -var4 - 1;

         for(var7 = 0; var7 <= var8; ++var7) {
            var6[var7] = var5;
         }

         System.arraycopy(this.chars, 0, var6, var7, var6.length - var7);
         return new Rexx(var6, true);
      }
   }

   public Rexx sequence(Rexx var1) throws BadArgumentException, NotCharacterException {
      boolean var7 = false;
      char var2 = this.padcheck();
      char var3 = var1.padcheck();
      char var4 = var2;
      int var5 = var3 - var2 + 1;
      if (var5 <= 0) {
         throw new BadArgumentException("final<start");
      } else {
         char[] var6 = new char[var5];
         int var8 = var5 - 1;

         for(int var9 = 0; var9 <= var8; ++var9) {
            var6[var9] = (char)(var9 + var4);
         }

         return new Rexx(var6, true);
      }
   }

   public Rexx sign() throws NumberFormatException {
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else {
         return new Rexx(this.ind);
      }
   }

   public Rexx space() {
      return this.space(new Rexx(1), toRexx(" "));
   }

   public Rexx space(Rexx var1) {
      return this.space(var1, toRexx(" "));
   }

   public Rexx space(Rexx var1, Rexx var2) {
      int var3 = var1.intcheck(0, 999999999);
      char var4 = var2.padcheck();
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return toRexx(RexxWords.space(this.chars, var3, var4));
   }

   public Rexx strip() throws BadArgumentException {
      return this.strip(toRexx("B"), toRexx(" "));
   }

   public Rexx strip(Rexx var1) throws BadArgumentException {
      return this.strip(var1, toRexx(" "));
   }

   public Rexx strip(Rexx var1, Rexx var2) throws BadArgumentException {
      int var5 = 0;
      int var6 = 0;
      char var3 = var1.optioncheck("BLT");
      char var4 = var2.padcheck();
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (this.chars.length == 0) {
         return new Rexx("");
      } else {
         if (var3 == 'T') {
            var5 = 0;
         } else {
            int var9 = this.chars.length - 1;

            for(var5 = 0; var5 <= var9 && this.chars[var5] == var4; ++var5) {
            }

            if (var5 == this.chars.length) {
               return new Rexx("");
            }
         }

         if (var3 == 'L') {
            var6 = this.chars.length - 1;
         } else {
            for(var6 = this.chars.length - 1; var6 >= 0 && this.chars[var6] == var4; --var6) {
            }

            if (var6 < 0) {
               return new Rexx("");
            }
         }

         if (var5 == 0 && var6 == this.chars.length - 1) {
            return new Rexx(this);
         } else {
            int var7 = var6 - var5 + 1;
            char[] var8 = new char[var7];
            System.arraycopy(this.chars, var5, var8, 0, var7);
            return new Rexx(var8, true);
         }
      }
   }

   public Rexx substr(Rexx var1) throws NotCharacterException, BadArgumentException {
      return this.substr(var1, (new Rexx(this.intlength() + 1 - var1.toint())).max(new Rexx(0)), toRexx(" "));
   }

   public Rexx substr(Rexx var1, Rexx var2) throws NotCharacterException, BadArgumentException {
      return this.substr(var1, var2, toRexx(" "));
   }

   public Rexx substr(Rexx var1, Rexx var2, Rexx var3) throws NotCharacterException, BadArgumentException {
      boolean var9 = false;
      int var4 = var1.intcheck(1, 999999999) - 1;
      int var5 = var2.intcheck(0, 999999999);
      char var6 = var3.padcheck();
      if (this.chars == null) {
         this.chars = this.layout();
      }

      int var7 = this.chars.length;
      char[] var8 = new char[var5];
      if (var4 + var5 <= var7) {
         System.arraycopy(this.chars, var4, var8, 0, var5);
      } else {
         if (var4 < var7) {
            System.arraycopy(this.chars, var4, var8, 0, var7 - var4);
         } else {
            var4 = var7;
         }

         int var10 = var5 - 1;

         for(int var11 = var7 - var4; var11 <= var10; ++var11) {
            var8[var11] = var6;
         }
      }

      return new Rexx(var8, true);
   }

   public Rexx subword(Rexx var1) {
      return this.subword(var1, this.length());
   }

   public Rexx subword(Rexx var1, Rexx var2) {
      int var3 = var1.intcheck(1, 999999999);
      int var4 = var2.intcheck(0, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return toRexx(RexxWords.subword(this.chars, var3, var4));
   }

   public Rexx translate(Rexx var1, Rexx var2) throws BadArgumentException {
      return this.translate(var1, var2, toRexx(" "));
   }

   public Rexx translate(Rexx var1, Rexx var2, Rexx var3) throws BadArgumentException {
      char var4 = var3.padcheck();
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (var1.chars == null) {
         var1.chars = var1.layout();
      }

      if (var2.chars == null) {
         var2.chars = var2.layout();
      }

      return toRexx(RexxUtil.translate(this.chars, var1.chars, var2.chars, var4));
   }

   public Rexx trunc() throws BadArgumentException, NumberFormatException {
      return this.trunc(new Rexx(0));
   }

   public Rexx trunc(Rexx var1) throws BadArgumentException, NumberFormatException {
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else {
         int var2 = var1.intcheck(0, 999999999);
         return new Rexx(RexxUtil.trunc(this, var2));
      }
   }

   public Rexx upper() throws BadArgumentException {
      return this.upper(new Rexx(1), this.length());
   }

   public Rexx upper(Rexx var1) throws BadArgumentException {
      return this.upper(var1, this.length());
   }

   public Rexx upper(Rexx var1, Rexx var2) throws BadArgumentException {
      boolean var7 = false;
      int var3 = var1.intcheck(1, 999999999) - 1;
      int var4 = var2.intcheck(0, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      int var5 = this.chars.length;
      if (var5 == 0) {
         return new Rexx("");
      } else {
         char[] var6 = new char[var5];
         if (var4 < var5 | var3 > 0) {
            System.arraycopy(this.chars, 0, var6, 0, var5);
         }

         int var8 = var5 - 1;
         int var9 = var4;

         for(int var10 = var3; var10 <= var8 && var9 > 0; ++var10) {
            var6[var10] = Character.toUpperCase(this.chars[var10]);
            --var9;
         }

         return new Rexx(var6, true);
      }
   }

   public Rexx verify(Rexx var1) {
      return this.verify(var1, toRexx("N"), new Rexx(1));
   }

   public Rexx verify(Rexx var1, Rexx var2) {
      return this.verify(var1, var2, new Rexx(1));
   }

   public Rexx verify(Rexx var1, Rexx var2, Rexx var3) {
      char var4 = var2.optioncheck("NM");
      int var5 = var3.intcheck(1, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (var1.chars == null) {
         var1.chars = var1.layout();
      }

      return var4 == 'N' ? new Rexx(RexxWords.verifyn(this.chars, var1.chars, var5)) : new Rexx(RexxWords.verifym(this.chars, var1.chars, var5));
   }

   public Rexx word(Rexx var1) {
      return this.subword(var1, new Rexx(1));
   }

   public Rexx wordindex(Rexx var1) {
      int var2 = var1.intcheck(1, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return new Rexx(RexxWords.wordindex(this.chars, var2));
   }

   public Rexx wordlength(Rexx var1) {
      int var2 = var1.intcheck(1, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return new Rexx(RexxWords.wordlength(this.chars, var2));
   }

   public Rexx wordpos(Rexx var1) {
      return this.wordpos(var1, new Rexx(1));
   }

   public Rexx wordpos(Rexx var1, Rexx var2) {
      int var3 = var2.intcheck(1, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (var1.chars == null) {
         var1.chars = var1.layout();
      }

      return new Rexx(RexxWords.wordpos(var1.chars, this.chars, var3));
   }

   public Rexx words() {
      return new Rexx(this.intwords());
   }

   public Rexx x2b() {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (this.chars.length == 0) {
         throw new BadArgumentException("No digits");
      } else {
         return new Rexx(RexxUtil.x2b(this));
      }
   }

   public Rexx x2c() {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (this.chars.length == 0) {
         throw new BadArgumentException("No digits");
      } else {
         return new Rexx(RexxUtil.x2c(this));
      }
   }

   public Rexx x2d(Rexx var1) throws BadArgumentException {
      int var2 = var1.intcheck(0, 999999999);
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return toRexx(RexxUtil.x2d(this, var2));
   }

   public Rexx x2d() throws BadArgumentException {
      if (this.chars == null) {
         this.chars = this.layout();
      }

      return toRexx(RexxUtil.x2d(this, -1));
   }

   public Rexx OpCc(RexxSet var1, Rexx var2) {
      return this.concat(var1, var2, 0);
   }

   public Rexx OpCcblank(RexxSet var1, Rexx var2) {
      return this.concat(var1, var2, 1);
   }

   public boolean OpEq(RexxSet var1, Rexx var2) {
      return this.docompare(var1, var2) == 0;
   }

   public boolean OpNotEq(RexxSet var1, Rexx var2) {
      return this.docompare(var1, var2) != 0;
   }

   public boolean OpLt(RexxSet var1, Rexx var2) {
      return this.docompare(var1, var2) < 0;
   }

   public boolean OpGt(RexxSet var1, Rexx var2) {
      return this.docompare(var1, var2) > 0;
   }

   public boolean OpLtEq(RexxSet var1, Rexx var2) {
      return this.docompare(var1, var2) <= 0;
   }

   public boolean OpGtEq(RexxSet var1, Rexx var2) {
      return this.docompare(var1, var2) >= 0;
   }

   public boolean OpEqS(RexxSet var1, Rexx var2) {
      return this.docomparestrict(var1, var2) == 0;
   }

   public boolean OpNotEqS(RexxSet var1, Rexx var2) {
      return this.docomparestrict(var1, var2) != 0;
   }

   public boolean OpLtS(RexxSet var1, Rexx var2) {
      return this.docomparestrict(var1, var2) < 0;
   }

   public boolean OpGtS(RexxSet var1, Rexx var2) {
      return this.docomparestrict(var1, var2) > 0;
   }

   public boolean OpLtEqS(RexxSet var1, Rexx var2) {
      return this.docomparestrict(var1, var2) <= 0;
   }

   public boolean OpGtEqS(RexxSet var1, Rexx var2) {
      return this.docomparestrict(var1, var2) >= 0;
   }

   public boolean OpOr(RexxSet var1, Rexx var2) {
      return this.toboolean() | var2.toboolean();
   }

   public boolean OpAnd(RexxSet var1, Rexx var2) {
      return this.toboolean() & var2.toboolean();
   }

   public boolean OpXor(RexxSet var1, Rexx var2) {
      return this.toboolean() ^ var2.toboolean();
   }

   public boolean OpNot(RexxSet var1) {
      return !this.toboolean();
   }

   public Rexx OpMinus(RexxSet var1) {
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else {
         Rexx var2 = new Rexx(this);
         var2.ind = (byte)(-var2.ind);
         var2.chars = null;
         if (var1 == null) {
            var2.dig = 9;
            var2.form = 0;
         } else {
            var2.dig = var1.digits;
            var2.form = var1.form;
         }

         return var2.finish(var2.dig, false);
      }
   }

   public Rexx OpPlus(RexxSet var1) {
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else {
         Rexx var2 = new Rexx(this);
         var2.chars = null;
         if (var1 == null) {
            var2.dig = 9;
            var2.form = 0;
         } else {
            var2.dig = var1.digits;
            var2.form = var1.form;
         }

         return var2.finish(var2.dig, false);
      }
   }

   public Rexx OpSub(RexxSet var1, Rexx var2) {
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else if (var2.ind == -2) {
         throw new NumberFormatException(String.valueOf(var2.chars));
      } else {
         Rexx var3 = new Rexx(var2);
         var3.ind = (byte)(-var3.ind);
         return this.OpAdd(var1, var3);
      }
   }

   public Rexx OpAdd(RexxSet var1, Rexx var2) {
      int var4 = 0;
      byte var5 = 0;
      Rexx var6 = null;
      Object var7 = null;
      Object var8 = null;
      int var9 = 0;
      boolean var10 = false;
      int var11 = 0;
      Object var12 = null;
      int var13 = 0;
      int var14 = 0;
      int var15 = 0;
      int var16 = 0;
      char var17 = '\u0000';
      char var18 = '\u0000';
      Object var19 = null;
      Rexx var3 = this;
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else if (var2.ind == -2) {
         throw new NumberFormatException(String.valueOf(var2.chars));
      } else {
         if (var1 == null) {
            var4 = 9;
            var5 = 0;
         } else {
            var4 = var1.digits;
            var5 = var1.form;
         }

         if (this.ind == 0) {
            var6 = new Rexx(var2);
            var6.chars = null;
            var6.dig = var4;
            var6.form = var5;
            return var6.finish(var4, false);
         } else if (var2.ind == 0) {
            var6 = new Rexx(this);
            var6.chars = null;
            var6.dig = var4;
            var6.form = var5;
            return var6.finish(var4, false);
         } else {
            if (this.mant.length > var4 + 1) {
               var3 = new Rexx(this);
               var3.cut(var4);
            }

            if (var2.mant.length > var4 + 1) {
               var2 = new Rexx(var2);
               var2.cut(var4);
            }

            var6 = new Rexx();
            var6.dig = var4;
            var6.form = var5;
            char[] var26;
            char[] var27;
            if (var3.exp == var2.exp) {
               var26 = var3.mant;
               var27 = var2.mant;
               var6.exp = var3.exp;
            } else if (var3.exp > var2.exp) {
               var9 = var3.mant.length + var3.exp - var2.exp;
               if (var9 > var2.mant.length + var4 + 1) {
                  var6.mant = var3.mant;
                  var6.exp = var3.exp;
                  var6.ind = var3.ind;
                  if (var6.mant.length < var4) {
                     var6.mant = new char[var4];
                     System.arraycopy(var3.mant, 0, var6.mant, 0, var3.mant.length);
                     int var46 = var4 - 1;

                     for(int var31 = var3.mant.length; var31 <= var46; ++var31) {
                        var6.mant[var31] = '0';
                     }

                     var6.exp -= var4 - var3.mant.length;
                  }

                  return var6.finish(var4, false);
               }

               var6.exp = var2.exp;
               if (var9 > var4 + 1) {
                  var11 = var9 - var4 - 1;
                  var27 = new char[var2.mant.length - var11];
                  System.arraycopy(var2.mant, 0, var27, 0, var27.length);
                  var6.exp += var11;
                  var9 = var4 + 1;
               } else {
                  var27 = var2.mant;
               }

               if (var9 > var3.mant.length) {
                  var26 = new char[var9];
                  System.arraycopy(var3.mant, 0, var26, 0, var3.mant.length);
                  int var20 = var9 - 1;

                  for(int var30 = var3.mant.length; var30 <= var20; ++var30) {
                     var26[var30] = '0';
                  }
               } else {
                  var26 = var3.mant;
               }
            } else {
               var9 = var2.mant.length + var2.exp - var3.exp;
               if (var9 > var3.mant.length + var4 + 1) {
                  var6.mant = var2.mant;
                  var6.exp = var2.exp;
                  var6.ind = var2.ind;
                  if (var6.mant.length < var4) {
                     var6.mant = new char[var4];
                     System.arraycopy(var2.mant, 0, var6.mant, 0, var2.mant.length);
                     int var49 = var4 - 1;

                     for(int var34 = var2.mant.length; var34 <= var49; ++var34) {
                        var6.mant[var34] = '0';
                     }

                     var6.exp -= var4 - var2.mant.length;
                  }

                  return var6.finish(var4, false);
               }

               var6.exp = var3.exp;
               if (var9 > var4 + 1) {
                  var11 = var9 - var4 - 1;
                  var26 = new char[var3.mant.length - var11];
                  System.arraycopy(var3.mant, 0, var26, 0, var26.length);
                  var6.exp += var11;
                  var9 = var4 + 1;
               } else {
                  var26 = var3.mant;
               }

               if (var9 > var2.mant.length) {
                  var27 = new char[var9];
                  System.arraycopy(var2.mant, 0, var27, 0, var2.mant.length);
                  int var47 = var9 - 1;

                  for(int var32 = var2.mant.length; var32 <= var47; ++var32) {
                     var27[var32] = '0';
                  }
               } else {
                  var27 = var2.mant;
               }
            }

            if (var3.ind == var2.ind) {
               var6.mant = charaddsub(var26, var27, 1);
               var6.ind = var3.ind;
               return var6.finish(var4, false);
            } else {
               var6.ind = var3.ind;
               if (var26.length <= var27.length) {
                  if (var26.length < var27.length) {
                     char[] var37 = var26;
                     var26 = var27;
                     var27 = var37;
                     var6.ind = (byte)(-var6.ind);
                  } else {
                     var13 = 0;
                     var14 = 0;
                     var15 = var26.length - 1;
                     var16 = var27.length - 1;

                     while(true) {
                        if (var13 <= var15) {
                           var17 = var26[var13];
                        } else {
                           if (var14 > var16) {
                              var6.mant = new char[1];
                              var6.mant[0] = '0';
                              var6.ind = 0;
                              var6.exp = 0;
                              return var6;
                           }

                           var17 = '0';
                        }

                        if (var14 <= var16) {
                           var18 = var27[var14];
                        } else {
                           var18 = '0';
                        }

                        if (var17 != var18) {
                           if (var17 < var18) {
                              char[] var38 = var26;
                              var26 = var27;
                              var27 = var38;
                              var6.ind = (byte)(-var6.ind);
                           }
                           break;
                        }

                        ++var13;
                        ++var14;
                     }
                  }
               }

               var6.mant = charaddsub(var26, var27, -1);
               if (var6.mant.length > var4) {
                  var6.round(var4);
               }

               if (var6.mant[0] == '0') {
                  int var48 = var6.mant.length;

                  for(int var33 = 1; var33 <= var48; ++var33) {
                     if (var33 == var6.mant.length) {
                        var6.mant = new char[1];
                        var6.mant[0] = '0';
                        var6.ind = 0;
                        var6.exp = 0;
                        return var6;
                     }

                     if (var6.mant[var33] != '0') {
                        char[] var45 = new char[var6.mant.length - var33];
                        System.arraycopy(var6.mant, var33, var45, 0, var6.mant.length - var33);
                        var6.mant = var45;
                        break;
                     }
                  }
               }

               return var6;
            }
         }
      }
   }

   public Rexx OpMult(RexxSet var1, Rexx var2) {
      int var4 = 0;
      byte var5 = 0;
      Object var7 = null;
      Object var8 = null;
      boolean var10 = false;
      int var11 = 0;
      Object var12 = null;
      Rexx var3 = this;
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else if (var2.ind == -2) {
         throw new NumberFormatException(String.valueOf(var2.chars));
      } else {
         if (var1 == null) {
            var4 = 9;
            var5 = 0;
         } else {
            var4 = var1.digits;
            var5 = var1.form;
         }

         if (this.mant.length > var4 + 1) {
            var3 = new Rexx(this);
            var3.cut(var4);
         }

         if (var2.mant.length > var4 + 1) {
            var2 = new Rexx(var2);
            var2.cut(var4);
         }

         Rexx var6 = new Rexx();
         var6.dig = var4;
         var6.form = var5;
         var6.ind = (byte)(var3.ind * var2.ind);
         var6.exp = var3.exp + var2.exp;
         char[] var15;
         char[] var16;
         if (var3.mant.length < var2.mant.length) {
            var15 = var3.mant;
            var16 = var2.mant;
         } else {
            var15 = var2.mant;
            var16 = var3.mant;
         }

         char[] var9 = new char[]{'0'};

         for(int var17 = var15.length - 1; var17 >= 0; --var17) {
            var11 = var15[var17] - 48;
            if (var11 > 0) {
               var9 = charaddsub(var9, var16, var11);
            }

            if (var17 == 0) {
               break;
            }

            char[] var19 = new char[var16.length + 1];
            System.arraycopy(var16, 0, var19, 0, var16.length);
            var19[var16.length] = '0';
            var16 = var19;
         }

         var6.mant = var9;
         return var6.finish(var4, false);
      }
   }

   public Rexx OpDiv(RexxSet var1, Rexx var2) {
      return this.dodivide('D', var1, var2);
   }

   public Rexx OpDivI(RexxSet var1, Rexx var2) {
      return this.dodivide('I', var1, var2);
   }

   public Rexx OpRem(RexxSet var1, Rexx var2) {
      return this.dodivide('R', var1, var2);
   }

   public Rexx OpPow(RexxSet var1, Rexx var2) {
      int var3 = 0;
      int var7 = 0;
      Object var8 = null;
      int var11 = 0;
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else {
         if (var1 == null) {
            var3 = 9;
         } else {
            var3 = var1.digits;
         }

         if (var2.mant.length > var3) {
            var2 = new Rexx(var2);
            var2.round(var3);
         }

         if (var2.mant.length + var2.exp > var3) {
            throw new BadArgumentException("Too many digits: " + var2.toString());
         } else {
            int var4 = var2.intcheck(-999999999, 999999999);
            Rexx var5 = this;
            if (this.mant.length > var3 + 1) {
               var5 = new Rexx(this);
               var5.cut(var3);
            }

            Rexx var6 = new Rexx(1);
            if (var2.exp == 0) {
               var7 = var2.mant.length;
            } else {
               var7 = (new Rexx(var4)).length().toint();
            }

            RexxSet var14;
            if (var1 == null) {
               var14 = new RexxSet(9 + var7 + 1);
            } else {
               var14 = new RexxSet(var1.digits + var7 + 1, var1.form);
            }

            Rexx var9 = var6;
            if (var4 == 0) {
               return var6;
            } else {
               if (var4 < 0) {
                  var4 = -var4;
               }

               boolean var10 = false;
               var11 = 1;

               while(true) {
                  var4 += var4;
                  if (var4 < 0) {
                     var10 = true;
                     var9 = var9.OpMult(var14, var5);
                  }

                  if (var11 == 31) {
                     if (var2.ind < 0) {
                        var9 = var6.OpDiv(var14, var9);
                     }

                     return var9.OpDiv(var1, var6);
                  }

                  if (var10) {
                     var9 = var9.OpMult(var14, var9);
                  }

                  ++var11;
               }
            }
         }
      }
   }

   private final Rexx dodivide(char var1, RexxSet var2, Rexx var3) throws NumberFormatException, DivideException {
      int var4 = 0;
      byte var5 = 0;
      Rexx var8 = null;
      boolean var11 = false;
      int var15 = 0;
      int var16 = 0;
      int var17 = 0;
      int var18 = 0;
      int var19 = 0;
      Object var20 = null;
      Object var21 = null;
      Object var22 = null;
      Object var24 = null;
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else if (var3.ind == -2) {
         throw new NumberFormatException(String.valueOf(var3.chars));
      } else if (var3.ind == 0) {
         throw new DivideException("Divide by 0");
      } else {
         if (var2 == null) {
            var4 = 9;
            var5 = 0;
         } else {
            var4 = var2.digits;
            var5 = var2.form;
         }

         Rexx var6 = this;
         if (this.ind == 0) {
            return new Rexx(0);
         } else {
            if (this.mant.length > var4 + 1) {
               var6 = new Rexx(this);
               var6.cut(var4);
            }

            if (var3.mant.length > var4 + 1) {
               var3 = new Rexx(var3);
               var3.cut(var4);
            }

            int var7 = var6.exp - var3.exp + var6.mant.length - var3.mant.length;
            if (var7 < 0 && var1 != 'D') {
               if (var1 == 'I') {
                  return new Rexx(0);
               } else {
                  var8 = new Rexx(var6);
                  var8.dig = var4;
                  var8.form = var5;
                  return var8.finish(var4, false);
               }
            } else {
               var8 = new Rexx();
               var8.ind = (byte)(var6.ind * var3.ind);
               var8.exp = var7;
               var8.dig = var4;
               var8.form = var5;
               var8.mant = new char[var4 + 1];
               int var9 = var4 + var4 + 1;
               char[] var10 = new char[var9];
               System.arraycopy(var6.mant, 0, var10, 0, var6.mant.length);
               int var25 = var9 - 1;

               for(int var33 = var6.mant.length; var33 <= var25; ++var33) {
                  var10[var33] = '0';
               }

               char[] var12 = new char[var9];
               System.arraycopy(var3.mant, 0, var12, 0, var3.mant.length);
               int var26 = var9 - 1;

               for(int var34 = var3.mant.length; var34 <= var26; ++var34) {
                  var12[var34] = '0';
               }

               int var13 = (var12[0] - 48) * 10 + var12[1] - 48 + 1;
               int var14 = 0;

               label200:
               while(true) {
                  var15 = 0;

                  label197:
                  while(var10.length >= var12.length) {
                     if (var10.length == var12.length) {
                        int var27 = var10.length - 1;

                        label191: {
                           for(int var35 = 0; var35 <= var27; ++var35) {
                              if (var10[var35] < var12[var35]) {
                                 break label197;
                              }

                              if (var10[var35] > var12[var35]) {
                                 break label191;
                              }
                           }

                           if (var1 != 'R') {
                              ++var15;
                              var8.mant[var14] = (char)(var15 + 48);
                              ++var14;
                              break label200;
                           }
                        }

                        var16 = var10[0] - 48;
                     } else {
                        var16 = (var10[0] - 48) * 10;
                        if (var10.length > 1) {
                           var16 = var16 + var10[1] - 48;
                        }
                     }

                     var17 = var16 * 10 / var13;
                     if (var17 == 0) {
                        var17 = 1;
                     }

                     var15 += var17;
                     var10 = charaddsub(var10, var12, -var17);
                     if (var10[0] == '0') {
                        var18 = var10.length;
                        int var48 = var18 - 2;

                        for(var19 = 0; var19 <= var48 && var10[var19] == '0'; ++var19) {
                           --var18;
                        }

                        char[] var44 = new char[var18];
                        System.arraycopy(var10, var19, var44, 0, var18);
                        var10 = var44;
                     }
                  }

                  if (var14 != 0 | var15 != 0) {
                     var8.mant[var14] = (char)(var15 + 48);
                     ++var14;
                     if (var14 == var4 + 1 || var10[0] == '0') {
                        break;
                     }
                  }

                  if (var1 != 'D' && var8.exp <= 0) {
                     break;
                  }

                  --var8.exp;
                  char[] var45 = new char[var12.length - 1];
                  System.arraycopy(var12, 0, var45, 0, var12.length - 1);
                  var12 = var45;
               }

               if (var1 == 'I' | var1 == 'R' && var14 + var8.exp > var4) {
                  throw new DivideException("Integer overflow");
               } else if (var1 != 'R') {
                  if (var14 == 0) {
                     return new Rexx(0);
                  } else {
                     if (var14 == var8.mant.length) {
                        var8.round(var4);
                        var14 = var4;
                     }

                     char[] var46 = new char[var14];
                     System.arraycopy(var8.mant, 0, var46, 0, var14);
                     var8.mant = var46;
                     return var8.finish(var4, true);
                  }
               } else if (var14 == 0) {
                  var8 = new Rexx(var6);
                  var8.chars = null;
                  var8.dig = var4;
                  var8.form = var5;
                  return var8.finish(var4, false);
               } else if (var10[0] == '0') {
                  return new Rexx(0);
               } else {
                  var8.ind = var6.ind;
                  int var23 = var4 + var4 + 1 - var6.mant.length;
                  var8.exp = var8.exp - var23 + var6.exp;
                  var18 = var10.length;

                  for(int var36 = var18 - 1; var36 >= 1 && var8.exp < var6.exp & var8.exp < var3.exp && var10[var36] == '0'; --var36) {
                     --var18;
                     ++var8.exp;
                  }

                  if (var18 < var10.length) {
                     char[] var47 = new char[var18];
                     System.arraycopy(var10, 0, var47, 0, var18);
                     var10 = var47;
                  }

                  var8.mant = var10;
                  return var8.finish(var4, false);
               }
            }
         }
      }
   }

   private void cut(int var1) {
      int var2 = this.mant.length - var1 - 1;
      if (var2 > 0) {
         this.exp += var2;
         char[] var3 = new char[var1 + 1];
         System.arraycopy(this.mant, 0, var3, 0, var1 + 1);
         this.mant = var3;
         this.chars = null;
      }
   }

   private void round(int var1) {
      Object var3 = null;
      int var2 = this.mant.length - var1;
      if (var2 > 0) {
         this.exp += var2;
         char[] var7;
         if (var2 > 1) {
            var7 = new char[var1 + 1];
            System.arraycopy(this.mant, 0, var7, 0, var1 + 1);
         } else {
            var7 = this.mant;
         }

         char[] var4 = new char[]{'5'};
         char[] var5 = charaddsub(var7, var4, 1);
         if (var5.length > var1 + 1) {
            ++this.exp;
         }

         char[] var6 = new char[var1];
         System.arraycopy(var5, 0, var6, 0, var1);
         this.mant = var6;
         this.chars = null;
      }
   }

   private static char[] charaddsub(char[] var0, char[] var1, int var2) {
      boolean var8 = false;
      int var9 = 0;
      int var3 = var0.length - 1;
      int var4 = var1.length - 1;
      int var5 = var3;
      if (var4 > var3) {
         var5 = var4;
      }

      char[] var6 = new char[var5 + 1];
      int var7 = 0;

      for(int var11 = var5; var11 >= 0; --var11) {
         var9 = var7;
         if (var3 >= 0) {
            var9 = var7 + var0[var3] - 48;
            --var3;
         }

         if (var4 >= 0) {
            var9 += (var1[var4] - 48) * var2;
            --var4;
         }

         if (var9 < 0) {
            var9 += 100;
            var7 = var9 / 10 - 10;
            var6[var11] = (char)(var9 % 10 + 48);
         } else if (var9 > 9) {
            var7 = var9 / 10;
            var6[var11] = (char)(var9 % 10 + 48);
         } else {
            var7 = 0;
            var6[var11] = (char)(var9 + 48);
         }
      }

      if (var7 == 0) {
         return var6;
      } else {
         char[] var10 = new char[var5 + 2];
         var10[0] = (char)(var7 + 48);
         System.arraycopy(var6, 0, var10, 1, var5 + 1);
         return var10;
      }
   }

   private Rexx concat(RexxSet var1, Rexx var2, int var3) {
      boolean var5 = false;
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (var2.chars == null) {
         var2.chars = var2.layout();
      }

      char[] var4 = new char[this.chars.length + var2.chars.length + var3];
      System.arraycopy(this.chars, 0, var4, 0, this.chars.length);
      if (var3 > 0) {
         int var6 = this.chars.length + var3 - 1;

         for(int var7 = this.chars.length; var7 <= var6; ++var7) {
            var4[var7] = ' ';
         }
      }

      System.arraycopy(var2.chars, 0, var4, this.chars.length + var3, var2.chars.length);
      return new Rexx(var4, true);
   }

   private static char[] sa2ca(String[] var0) {
      boolean var3 = false;
      int var6 = 0;
      int var1 = var0.length - 1;
      if (var1 < 0) {
         return new char[0];
      } else {
         int var2 = var1;
         int var7 = var1;

         for(int var9 = 0; var9 <= var7; ++var9) {
            var2 += var0[var9].length();
         }

         char[] var4 = new char[var2];
         int var5 = 0;
         int var8 = var1;

         for(int var10 = 0; var10 <= var8; ++var10) {
            var6 = var0[var10].length();
            var0[var10].getChars(0, var6, var4, var5);
            if (var10 == var1) {
               break;
            }

            var5 = var5 + var6 + 1;
            var4[var5 - 1] = ' ';
         }

         return var4;
      }
   }

   private final int docompare(RexxSet var1, Rexx var2) {
      int var3 = 0;
      boolean var4 = false;
      Rexx var5 = null;
      Object var6 = null;
      char var13 = '\u0000';
      char var14 = '\u0000';
      if (this.ind != -2 && var2.ind != -2) {
         if (this.ind == var2.ind & this.exp == var2.exp) {
            var3 = this.mant.length;
            if (var3 < var2.mant.length) {
               return (byte)(-this.ind);
            }

            if (var3 > var2.mant.length) {
               return this.ind;
            }

            this.dig = 9;
            if (var1 != null) {
               this.dig = var1.digits;
            }

            if (var3 <= this.dig) {
               int var27 = var3 - 1;

               for(int var18 = 0; var18 <= var27; ++var18) {
                  if (this.mant[var18] < var2.mant[var18]) {
                     return (byte)(-this.ind);
                  }

                  if (this.mant[var18] > var2.mant[var18]) {
                     return this.ind;
                  }
               }

               return 0;
            }
         } else {
            if (this.ind < var2.ind) {
               return -1;
            }

            if (this.ind > var2.ind) {
               return 1;
            }
         }

         var5 = new Rexx(var2);
         var5.ind = (byte)(-var5.ind);
         Rexx var20 = this.OpAdd(var1, var5);
         return var20.ind;
      } else {
         if (this.chars == null) {
            this.chars = this.layout();
         }

         char[] var7 = this.chars;
         if (var2.chars == null) {
            var2.chars = var2.layout();
         }

         char[] var8 = var2.chars;
         int var9 = 0;
         int var10 = 0;
         int var11 = var7.length - 1;

         int var12;
         for(var12 = var8.length - 1; var11 >= 0 && var7[var11] == ' '; --var11) {
         }

         while(var12 >= 0 && var8[var12] == ' ') {
            --var12;
         }

         int var15 = var11;

         for(var9 = 0; var9 <= var15 && var7[var9] == ' '; ++var9) {
         }

         int var16 = var12;

         for(var10 = 0; var10 <= var16 && var8[var10] == ' '; ++var10) {
         }

         while(true) {
            if (var9 <= var11) {
               var13 = var7[var9];
            } else {
               var13 = ' ';
            }

            if (var10 <= var12) {
               var14 = var8[var10];
            } else {
               var14 = ' ';
            }

            if (var14 == var13) {
               if (var14 == ' ' && var9 > var11 && var10 > var12) {
                  return 0;
               }

               ++var9;
               ++var10;
            } else {
               var13 = Character.toLowerCase(var13);
               var14 = Character.toLowerCase(var14);
               if (var14 != var13) {
                  if (var13 < var14) {
                     return -1;
                  }

                  return 1;
               }

               ++var9;
               ++var10;
            }
         }
      }
   }

   private final int docomparestrict(RexxSet var1, Rexx var2) {
      char var9 = '\u0000';
      char var10 = '\u0000';
      if (this.chars == null) {
         this.chars = this.layout();
      }

      char[] var3 = this.chars;
      if (var2.chars == null) {
         var2.chars = var2.layout();
      }

      char[] var4 = var2.chars;
      int var5 = 0;
      int var6 = 0;
      int var7 = var3.length - 1;
      int var8 = var4.length - 1;

      while(true) {
         if (var5 <= var7) {
            var9 = var3[var5];
         } else {
            if (var6 > var8) {
               return 0;
            }

            var9 = '\u0000';
         }

         if (var6 <= var8) {
            var10 = var4[var6];
         } else {
            var10 = '\u0000';
         }

         if (var10 != var9) {
            if (var9 < var10) {
               return -1;
            }

            return 1;
         }

         ++var5;
         ++var6;
      }
   }

   private final Rexx finish(int var1, boolean var2) {
      int var3 = 0;
      boolean var4 = false;
      Object var5 = null;
      int var6 = 0;
      int var7 = 0;
      if (this.mant.length > var1) {
         this.round(var1);
      }

      if (var2) {
         var3 = this.mant.length;

         for(int var10 = var3 - 1; var10 >= 1 && this.mant[var10] == '0'; --var10) {
            --var3;
            ++this.exp;
         }

         if (var3 < this.mant.length) {
            char[] var12 = new char[var3];
            System.arraycopy(this.mant, 0, var12, 0, var3);
            this.mant = var12;
         }
      }

      int var8 = this.mant.length - 1;

      for(int var11 = 0; var11 <= var8; ++var11) {
         if (this.mant[var11] != '0') {
            var6 = this.exp + this.mant.length - 1;
            if (var6 < -999999999 | var6 > 999999999) {
               if (this.form != 1) {
                  throw new ExponentOverflowException(String.valueOf(var6));
               }

               var7 = var6 % 3;
               if (var7 < 0) {
                  var7 += 3;
               }

               var6 -= var7;
               if (var6 < -999999999 || var6 > -999999999) {
                  throw new ExponentOverflowException(String.valueOf(var6));
               }
            }

            return this;
         }
      }

      if (this.mant.length == 1 && this.ind == 0 && this.exp == 0) {
         return this;
      } else {
         return new Rexx(0);
      }
   }
}