PC Online 1997 May/PCO_5_97.ISO/FilesBBS/OS2/NETREXX.ARJ/NETREXX.ZIP/NetRexx/netrexx/lang/Rexx.class

Java Class File | 1997-02-18 | 32.4 KB | 2,960 lines

package netrexx.lang;

import java.util.Enumeration;
import java.util.Hashtable;

public class Rexx implements RexxOperators {
   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 = (new Rexx("0123456789ABCDEFabcdef")).toCharArray();
   protected static final byte ispos = 1;
   protected static final byte iszero = 0;
   protected static final byte isneg = -1;
   protected static final byte NotaNum = -2;
   protected static final int MinExp = -999999999;
   protected static final int MaxExp = 999999999;
   protected static final int MinArg = -999999999;
   protected static final int MaxArg = 999999999;
   protected char[] chars;
   protected byte ind;
   protected byte form;
   protected char[] mant;
   protected int exp;
   protected int dig;
   protected Hashtable coll;
   private static final Rexx $$77 = new Rexx("0000");
   private static final Rexx $$79 = new Rexx(0);
   // $FF: renamed from: $0 java.lang.String
   private static final String field_0 = "Rexx.nrx";

   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.dig = 10;
      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;
         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));
   }

   protected 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 (!RexxCharX.isDigit(var1[0])) {
               return;
            }
         }

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

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

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

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

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

                     if (var5 != 0) {
                        return;
                     }

                     var5 = 1;
                  }
               }
            }

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

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

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

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

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

                           var11 = false;
                        }

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

                        int var18 = var3 - 1;

                        for(int var27 = var22 + 2; var27 <= var18; ++var27) {
                           if (var1[var27] < '0') {
                              return;
                           }

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

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

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

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

                     if (!RexxCharX.isDigit(var1[var22])) {
                        return;
                     }

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

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

                  int var33 = var10 - 1;

                  for(int var23 = var6; var23 <= var33; ++var23) {
                     if (var1[var23] == '.') {
                        ++var6;
                     } else {
                        if (var1[var23] != '0') {
                           break;
                        }

                        ++var6;
                        --var8;
                     }
                  }

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

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

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

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

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

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

                  this.ind = (byte)(this.mant[0] != '0' ? 1 : 0);
                  if (var5 < 0) {
                     this.ind = (byte)(-this.ind);
                  }

               }
            }
         }
      }
   }

   protected 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;
   }

   public 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(var1.toString().toCharArray())) == 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 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 != -2 && 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((new Rexx("Decimal part non-zero:")).OpCcblank((RexxSet)null, this).toString());
               }
            }

            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((new Rexx("Decimal part non-zero:")).OpCcblank((RexxSet)null, this).toString());
               }
            }

            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;
         }
      }
   }

   protected 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(new Rexx("Internal error: Rexx missing number " + String.valueOf(this.chars)));
      }

      if (this.dig < 0) {
         RexxIO.Say(new Rexx("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);
               int var20 = var4 - this.mant.length;

               while(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('.');
            int var19 = -var1;

            while(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);
            int var7 = var1 - this.mant.length;

            while(var7 > 0) {
               --var7;
               var8.append('0');
            }

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

   protected static int hexint(char var0) {
      if (var0 >= '0' && var0 <= '9') {
         return var0 - 48;
      } else if (var0 >= 'A' && var0 <= 'F') {
         return var0 - 65 + 10;
      } else {
         return var0 >= 'a' && var0 <= 'f' ? var0 - 97 + 10 : -1;
      }
   }

   protected 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];
      }
   }

   protected 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) {
            byte var5 = 0;

            for(int var6 = this.exp + 1; var6 <= var5; ++var6) {
               if (this.mant[var3] != '0') {
                  throw new NumberFormatException((new Rexx("Non-zero decimal part in")).OpCcblank((RexxSet)null, this).toString());
               }

               --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;
         }
      }
   }

   protected 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 = Character.toUpperCase(this.chars[0]);
         if (var1.indexOf(var2) < 0) {
            throw new BadArgumentException("Bad Option character " + var2);
         } else {
            return var2;
         }
      }
   }

   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;
         byte var6 = 0;

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

               var3 += var4;
            }

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

         return new Rexx(var1);
      }
   }

   public Rexx centre(Rexx var1) {
      return this.centre(var1, new Rexx(' '));
   }

   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 new Rexx(RexxWords.centre(this.chars, var3, var4));
   }

   public Rexx center(Rexx var1) {
      return this.center(var1, new Rexx(' '));
   }

   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 new Rexx(RexxWords.changestr(var1.chars, this.chars, var2.chars));
   }

   public Rexx compare(Rexx var1) {
      return this.compare(var1, new Rexx(' '));
   }

   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; var5 += var3) {
         --var6;
         System.arraycopy(this.chars, 0, var4, var5, var3);
      }

      return new Rexx(var4, true);
   }

   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 = $$77.toCharArray();
      var2[3] = Hexes[var1 % 16];
      var1 /= 16;
      if (var1 == 0) {
         return (new Rexx(var2)).right(new Rexx((byte)1));
      } else {
         var2[2] = Hexes[var1 % 16];
         var1 /= 16;
         if (var1 == 0) {
            return (new Rexx(var2)).right(new Rexx((byte)2));
         } else {
            var2[1] = Hexes[var1 % 16];
            var1 /= 16;
            if (var1 == 0) {
               return (new Rexx(var2)).right(new Rexx((byte)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(new Rexx("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")).OpEq((RexxSet)null, $$79) ? 1 : 0;
      } else if (var2 == 'B') {
         var3 = this.verify(new Rexx("01")).OpEq((RexxSet)null, $$79) ? 1 : 0;
      } else if (var2 == 'D') {
         var3 = this.verify(new Rexx("0123456789")).OpEq((RexxSet)null, $$79) ? 1 : 0;
      } else if (var2 == 'L') {
         var3 = this.verify(new Rexx("abcdefghijklmnopqrstuvwxyz")).OpEq((RexxSet)null, $$79) ? 1 : 0;
      } else if (var2 == 'M') {
         var3 = this.verify(new Rexx("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")).OpEq((RexxSet)null, $$79) ? 1 : 0;
      } else if (var2 == 'N') {
         var3 = this.ind != -2 ? 1 : 0;
      } else if (var2 == 'S') {
         var3 = this.verify(new Rexx('_' + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789")).OpEq((RexxSet)null, $$79) & this.left(new Rexx((byte)1)).verify(new Rexx("0123456789")).OpNotEq((RexxSet)null, $$79) ? 1 : 0;
      } else if (var2 == 'U') {
         var3 = this.verify(new Rexx("ABCDEFGHIJKLMNOPQRSTUVWXYZ")).OpEq((RexxSet)null, $$79) ? 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('.')).OpEq((RexxSet)null, $$79) ? 1 : 0;
         }
      } else {
         if (var2 != 'X') {
            throw new NoOtherwiseException();
         }

         var3 = this.verify(new Rexx(Hexes)).OpEq((RexxSet)null, $$79) ? 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 new Rexx(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 new Rexx(RexxWords.delword(this.chars, var3, var4));
   }

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

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

      return new Rexx(RexxUtil.d2x(this, var2));
   }

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

      return new Rexx(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()), new Rexx(' '));
   }

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

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

   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 {
      return this.lastpos(var1, new Rexx(this.intlength()));
   }

   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;
         byte var7 = 0;

         label40:
         for(int var10 = var3; var10 >= var7; --var10) {
            int var8 = var4 - 1;

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

            return new Rexx(var10 + 1);
         }

         return new Rexx(0);
      }
   }

   public Rexx left(Rexx var1) {
      return this.left(var1, new Rexx(' '));
   }

   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), new Rexx(this.intlength()));
   }

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

   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) {
            --var9;
            var6[var10] = RexxCharX.toLowerCase(this.chars[var10]);
         }

         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()), new Rexx(' '));
   }

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

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

   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, new Rexx(' '));
   }

   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), new Rexx(' '));
   }

   public Rexx space(Rexx var1) {
      return this.space(var1, new Rexx(' '));
   }

   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 new Rexx(RexxWords.space(this.chars, var3, var4));
   }

   public Rexx strip() throws BadArgumentException {
      return this.strip(new Rexx('B'), new Rexx(' '));
   }

   public Rexx strip(Rexx var1) throws BadArgumentException {
      return this.strip(var1, new Rexx(' '));
   }

   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 {
            byte var12 = 0;

            for(var6 = this.chars.length - 1; var6 >= var12 && 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)).OpSub((RexxSet)null, var1), new Rexx(' '));
   }

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

   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 {
         System.arraycopy(this.chars, var4, var8, 0, var7 - var4);
         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, new Rexx(this.intlength()));
   }

   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 new Rexx(RexxWords.subword(this.chars, var3, var4));
   }

   public Rexx translate(Rexx var1, Rexx var2) {
      return this.translate(var1, var2, new Rexx(' '));
   }

   public Rexx translate(Rexx var1, Rexx var2, Rexx var3) {
      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 new Rexx(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), new Rexx(this.intlength()));
   }

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

   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) {
            --var9;
            var6[var10] = RexxCharX.toUpperCase(this.chars[var10]);
         }

         return new Rexx(var6, true);
      }
   }

   public Rexx verify(Rexx var1) {
      return this.verify(var1, new Rexx('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((byte)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() {
      boolean var2 = false;
      int var3 = 0;
      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 * 4];
         int var4 = this.chars.length - 1;

         for(int var5 = 0; var5 <= var4; ++var5) {
            var3 = hexint(this.chars[var5]);
            if (var3 < 0) {
               throw new BadArgumentException((new Rexx("Bad hexadecimal")).OpCcblank((RexxSet)null, this).toString());
            }

            if (var3 > 7) {
               var1[var5 * 4] = '1';
            } else {
               var1[var5 * 4] = '0';
            }

            if ((var3 & 4) != 0) {
               var1[var5 * 4 + 1] = '1';
            } else {
               var1[var5 * 4 + 1] = '0';
            }

            if ((var3 & 2) != 0) {
               var1[var5 * 4 + 2] = '1';
            } else {
               var1[var5 * 4 + 2] = '0';
            }

            if ((var3 & 1) != 0) {
               var1[var5 * 4 + 3] = '1';
            } else {
               var1[var5 * 4 + 3] = '0';
            }
         }

         return new Rexx(var1);
      }
   }

   public Rexx x2c() {
      int var2 = 0;
      int var3 = 0;
      if (this.chars == null) {
         this.chars = this.layout();
      }

      if (this.chars.length == 0) {
         throw new BadArgumentException("No digits");
      } else {
         int var1 = 0;
         int var4 = this.chars.length - 2;

         for(var2 = 0; var2 <= var4 && !(new Rexx(this.chars[var2])).OpNotEq((RexxSet)null, $$79); ++var2) {
         }

         for(int var5 = this.chars.length - 1; var2 <= var5; ++var2) {
            var3 = hexint(this.chars[var2]);
            if (var3 < 0) {
               throw new BadArgumentException((new Rexx("Bad hexadecimal")).OpCcblank((RexxSet)null, this).toString());
            }

            var1 = var1 * 16 + var3;
            if (var1 > 65535) {
               throw new BadArgumentException((new Rexx("Too big")).OpCcblank((RexxSet)null, this).toString());
            }
         }

         return new Rexx((char)var1);
      }
   }

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

      return new Rexx(RexxUtil.x2d(this, var2));
   }

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

      return new Rexx(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.check0(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.check0(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) {
      Rexx var5 = null;
      Object var6 = null;
      Object var7 = null;
      int var8 = 0;
      boolean var9 = false;
      Object var10 = null;
      int var11 = 0;
      int var12 = 0;
      int var13 = 0;
      int var14 = 0;
      char var15 = '\u0000';
      char var16 = '\u0000';
      Object var17 = null;
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else if (var2.ind == -2) {
         throw new NumberFormatException(String.valueOf(var2.chars));
      } else {
         int var3 = 9;
         byte var4 = 0;
         if (var1 != null) {
            var3 = var1.digits;
            var4 = var1.form;
         }

         if (this.ind == 0) {
            var5 = new Rexx(var2);
            var5.chars = null;
            var5.dig = var3;
            var5.form = var4;
            return var5.check0(var3, false);
         } else if (var2.ind == 0) {
            var5 = new Rexx(this);
            var5.chars = null;
            var5.dig = var3;
            var5.form = var4;
            return var5.check0(var3, false);
         } else {
            var5 = new Rexx();
            var5.dig = var3;
            var5.form = var4;
            char[] var24;
            char[] var25;
            if (this.exp == var2.exp) {
               var24 = this.mant;
               var25 = var2.mant;
               var5.exp = this.exp;
            } else if (this.exp > var2.exp) {
               var8 = this.mant.length + this.exp - var2.exp;
               if (var8 > var2.mant.length + var3) {
                  var5 = new Rexx(this);
                  var5.chars = null;
                  var5.dig = var3;
                  var5.form = var4;
                  return var5.check0(var3, false);
               }

               var24 = new char[var8];
               var25 = var2.mant;
               var5.exp = var2.exp;
               System.arraycopy(this.mant, 0, var24, 0, this.mant.length);
               int var18 = var8 - 1;

               for(int var28 = this.mant.length; var28 <= var18; ++var28) {
                  var24[var28] = '0';
               }
            } else {
               var8 = var2.mant.length + var2.exp - this.exp;
               if (var8 > this.mant.length + var3) {
                  var5 = new Rexx(var2);
                  var5.chars = null;
                  var5.dig = var3;
                  var5.form = var4;
                  return var5.check0(var3, false);
               }

               var24 = this.mant;
               var25 = new char[var8];
               var5.exp = this.exp;
               System.arraycopy(var2.mant, 0, var25, 0, var2.mant.length);
               int var40 = var8 - 1;

               for(int var29 = var2.mant.length; var29 <= var40; ++var29) {
                  var25[var29] = '0';
               }
            }

            if (this.ind == var2.ind) {
               var5.mant = charaddsub(var24, var25, 1);
               var5.ind = this.ind;
               return var5.check0(var3, false);
            } else {
               var5.ind = this.ind;
               if (var24.length <= var25.length) {
                  if (var24.length < var25.length) {
                     char[] var31 = var24;
                     var24 = var25;
                     var25 = var31;
                     var5.ind = (byte)(-var5.ind);
                  } else {
                     var11 = 0;
                     var12 = 0;
                     var13 = var24.length - 1;
                     var14 = var25.length - 1;

                     while(true) {
                        if (var11 <= var13) {
                           var15 = var24[var11];
                        } else {
                           if (var12 > var14) {
                              var5.mant = new char[1];
                              var5.mant[0] = '0';
                              var5.ind = 0;
                              var5.exp = 0;
                              return var5;
                           }

                           var15 = '0';
                        }

                        if (var12 <= var14) {
                           var16 = var25[var12];
                        } else {
                           var16 = '0';
                        }

                        if (var15 != var16) {
                           if (var15 < var16) {
                              char[] var32 = var24;
                              var24 = var25;
                              var25 = var32;
                              var5.ind = (byte)(-var5.ind);
                           }
                           break;
                        }

                        ++var11;
                        ++var12;
                     }
                  }
               }

               var5.mant = charaddsub(var24, var25, -1);
               if (var5.mant.length > var3) {
                  var5.round(var3);
               }

               if (var5.mant[0] == '0') {
                  int var41 = var5.mant.length;

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

                     if (var5.mant[var30] != '0') {
                        char[] var39 = new char[var5.mant.length - var30];
                        System.arraycopy(var5.mant, var30, var39, 0, var5.mant.length - var30);
                        var5.mant = var39;
                        break;
                     }
                  }
               }

               return var5;
            }
         }
      }
   }

   public Rexx OpMult(RexxSet var1, Rexx var2) {
      int var3 = 0;
      byte var4 = 0;
      Object var6 = null;
      Object var7 = null;
      boolean var9 = false;
      int var10 = 0;
      Object var11 = null;
      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) {
            var3 = 9;
            var4 = 0;
         } else {
            var3 = var1.digits;
            var4 = var1.form;
         }

         Rexx var5 = new Rexx();
         var5.dig = var3;
         var5.form = var4;
         var5.ind = (byte)(this.ind * var2.ind);
         var5.exp = this.exp + var2.exp;
         if (var5.exp < -999999999 | var5.exp > 999999999) {
            throw new ExponentOverflowException();
         } else {
            char[] var15;
            char[] var16;
            if (this.mant.length < var2.mant.length) {
               var15 = this.mant;
               var16 = var2.mant;
            } else {
               var15 = var2.mant;
               var16 = this.mant;
            }

            char[] var8 = new char[]{'0'};
            byte var12 = 0;

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

               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;
            }

            var5.mant = var8;
            return var5.check0(var3, 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 var5 = 0;
      Object var6 = null;
      int var9 = 0;
      if (this.ind == -2) {
         throw new NumberFormatException(String.valueOf(this.chars));
      } else {
         int var3 = var2.intcheck(-999999999, 999999999);
         Rexx var4 = new Rexx(1);
         if (var2.exp == 0) {
            var5 = var2.mant.length;
         } else {
            var5 = (new Rexx(var3)).length().toint();
         }

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

         Rexx var7 = var4;
         if (var3 == 0) {
            return var4;
         } else {
            if (var3 < 0) {
               var3 = -var3;
            }

            boolean var8 = false;
            var9 = 1;

            while(true) {
               var3 += var3;
               if (var3 < 0) {
                  var8 = true;
                  var7 = var7.OpMult(var11, this);
               }

               if (var9 == 31) {
                  var11.digits = var11.digits - var5 - 1;
                  if (var2.ind < 0) {
                     return var4.OpDiv(var11, var7);
                  }

                  return var7.OpDiv(var11, var4);
               }

               if (var8) {
                  var7 = var7.OpMult(var11, var7);
               }

               ++var9;
            }
         }
      }
   }

   private final Rexx dodivide(char var1, RexxSet var2, Rexx var3) throws NumberFormatException, DivideException, ExponentOverflowException {
      int var4 = 0;
      byte var5 = 0;
      Rexx var7 = 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;
         }

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

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

            int var8 = this.exp - var3.exp + this.mant.length - var3.mant.length;
            if (var8 < -999999999 | var8 > 999999999) {
               throw new ExponentOverflowException();
            } else if (var8 < 0 && var1 != 'D') {
               if (var1 == 'I') {
                  var7 = new Rexx(0);
               } else {
                  var7 = new Rexx(this);
               }

               var7.dig = var4;
               var7.form = var5;
               return var7.check0(var4, true);
            } else {
               var7 = new Rexx();
               var7.ind = (byte)(this.ind * var3.ind);
               var7.exp = var8;
               var7.dig = var4;
               var7.form = var5;
               var7.mant = new char[var4 + 1];
               int var9 = var4 + var4 + 1;
               char[] var10 = new char[var9];
               System.arraycopy(this.mant, 0, var10, 0, this.mant.length);
               int var25 = var9 - 1;

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

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

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

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

               label231:
               while(true) {
                  var15 = 0;

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

                        label222: {
                           for(int var36 = 0; var36 <= var27; ++var36) {
                              if (var10[var36] < var12[var36]) {
                                 break label228;
                              }

                              if (var10[var36] > var12[var36]) {
                                 break label222;
                              }
                           }

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

                        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 var49 = var18 - 2;

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

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

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

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

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

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

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

                  for(int var37 = var18 - 1; var37 >= var50 && var7.exp < 0 & var23 > 0 && var10[var37] == '0'; --var37) {
                     --var18;
                     ++var7.exp;
                     --var23;
                  }

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

                  var7.mant = var10;
                  if (var7.mant.length <= var4 && var7.exp < -999999999 | var7.exp > 999999999) {
                     throw new ExponentOverflowException();
                  } else {
                     return var7.check0(var4, false);
                  }
               }
            }
         }
      }
   }

   private final 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;
      }
   }

   private void round(int var1) throws ExponentOverflowException {
      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;
         }

         if (this.exp < -999999999 | this.exp > 999999999) {
            throw new ExponentOverflowException();
         } else {
            char[] var6 = new char[var1];
            System.arraycopy(var5, 0, var6, 0, var1);
            this.mant = var6;
         }
      }
   }

   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;
      byte var11 = 0;

      for(int var12 = var5; var12 >= var11; --var12) {
         if (var4 < 0) {
            var9 = var0[var3] - 48 + var7;
            --var3;
         } else {
            if (var3 >= 0) {
               var9 = var0[var3] - 48 + (var1[var4] - 48) * var2 + var7;
               --var3;
            } else {
               var9 = (var1[var4] - 48) * var2 + var7;
            }

            --var4;
         }

         if (var9 < 0) {
            var9 += 100;
            var7 = var9 / 10 - 10;
            var6[var12] = (char)(var9 % 10 + 48);
         } else if (var9 > 9) {
            var7 = var9 / 10;
            var6[var12] = (char)(var9 % 10 + 48);
         } else {
            var7 = 0;
            var6[var12] = (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 var29 = var3 - 1;

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

                  if (this.mant[var20] > var2.mant[var20]) {
                     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 var22 = this.OpAdd(var1, var5);
         return var22.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 = var8.length - 1;

         for(byte var15 = 0; var11 >= var15 && var7[var11] == ' '; --var11) {
         }

         for(byte var16 = 0; var12 >= var16 && var8[var12] == ' '; --var12) {
         }

         int var17 = var11;

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

         int var18 = var12;

         for(var10 = 0; var10 <= var18 && 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 = RexxCharX.toLowerCase(var13);
               var14 = RexxCharX.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 static int mantcompare(char[] var0, char[] var1) {
      boolean var2 = false;
      if (var0.length < var1.length) {
         return -1;
      } else if (var0.length > var1.length) {
         return 1;
      } else {
         int var3 = var0.length - 1;

         for(int var4 = 0; var4 <= var3; ++var4) {
            if (var0[var4] < var1[var4]) {
               return -1;
            }

            if (var0[var4] > var1[var4]) {
               return 1;
            }
         }

         return 0;
      }
   }

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

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

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

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

      int var11 = this.mant.length - 1;

      for(int var9 = 0; var9 <= var11; ++var9) {
         if (this.mant[var9] != '0') {
            return this;
         }
      }

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