Source code

001// ***** This file is automatically generated from FunctionBinary.java.jpp
002// ***** (and files it recursively includes).
003
004package daikon.inv.ternary.threeScalar;
005
006import daikon.*;
007import daikon.derive.unary.*;
008import daikon.inv.*;
009import daikon.inv.binary.twoScalar.*;
010import daikon.inv.unary.scalar.*;
011import daikon.suppress.*;
012import java.lang.reflect.*;
013import java.util.*;
014import java.util.logging.Logger;
015import org.checkerframework.checker.lock.qual.GuardSatisfied;
016import org.checkerframework.checker.nullness.qual.Nullable;
017import org.checkerframework.dataflow.qual.Pure;
018import org.checkerframework.dataflow.qual.SideEffectFree;
019import org.plumelib.util.ArraysPlume;
020import org.plumelib.util.MathPlume;
021import typequals.prototype.qual.NonPrototype;
022import typequals.prototype.qual.Prototype;
023
024/**
025 * Base class for each of the FunctionBinary functions and permutatons. Most of the work is done
026 * here. The subclasses basically define the function and return information describing the function
027 * and permutation to these methods.
028 */
029@SuppressWarnings("UnusedVariable")  // generated code, complex rules for when var is used
030public abstract class FunctionBinary extends ThreeScalar {
031  // We are Serializable, so we specify a version to allow changes to
032  // method signatures without breaking serialization.  If you add or
033  // remove fields, you should change this number to the current date.
034  static final long serialVersionUID = 20031030L;
035
036  /** Boolean. True if FunctionBinary invariants should be considered. */
037  public static boolean dkconfig_enabled = false;
038
039  public static Logger debug =
040    Logger.getLogger("daikon.inv.ternary.threeScalar.#CLASSNAME");
041
042  static final int[][] var_indices;
043  static {
044    var_indices = new int[7][];
045    var_indices[1] = new int[] { 0, 1, 2 };
046    var_indices[2] = new int[] { 1, 0, 2 };
047    var_indices[3] = new int[] { 2, 0, 1 };
048    var_indices[4] = new int[] { 0, 2, 1 };
049    var_indices[5] = new int[] { 1, 2, 0 };
050    var_indices[6] = new int[] { 2, 1, 0 };
051  }
052
053  protected FunctionBinary(PptSlice ppt) {
054    super(ppt);
055  }
056
057  protected @Prototype FunctionBinary() {
058    super();
059  }
060
061  /** returns whether or not this invariant is enabled */
062  @Override
063  public boolean enabled() {
064    return dkconfig_enabled;
065  }
066
067  /** FunctionBinary is only valid on isIntegral() types. */
068  @Override
069  public boolean instantiate_ok(VarInfo[] vis) {
070
071    if (!valid_types(vis)) {
072      return false;
073    }
074
075    // Make sure that each variable is integral (not boolean or hashcode)
076    if (!vis[0].file_rep_type.isIntegral()
077        || !vis[1].file_rep_type.isIntegral()
078        || !vis[2].file_rep_type.isIntegral())
079      return false;
080
081    return true;
082  }
083
084  // check_modified relies on func having no side effects.
085  abstract long func(long arg1, long arg2);
086  @Pure
087  abstract boolean is_symmetric();
088  abstract String[] get_method_name(@GuardSatisfied FunctionBinary this);
089  abstract int get_var_order(@GuardSatisfied FunctionBinary this);
090  abstract void set_function_id(int function_id);
091  abstract int get_function_id();
092
093  /**
094   * Map from function name (eg, MultiplyLong, MinimumFloat) to an array of instances (one for each
095   * valid permutation) for that function.
096   */
097  private static Map<String,@Prototype FunctionBinary[]> functions = new LinkedHashMap<>();
098
099  /**
100   * A list indexed by function number to an array of instances (one for each valid permutation) for
101   * that function. The array is the same one as is stored in the functions Map. This provides a
102   * faster access mechanism once we have the function id (which are calculated the first time
103   * through).
104   */
105  private static List<@Prototype FunctionBinary[]> func_list = new ArrayList<>();
106
107  private static void build_func_list() {
108
109    // Reflection seems to confuse clover
110    ///CLOVER:OFF
111
112    // Build the map of functions to array of instances for that function
113    debug.fine("Processing FunctionBinary");
114    functions = new LinkedHashMap<>();
115    @SuppressWarnings("unchecked")
116    Class<@Prototype FunctionBinary>[] subclasses = (Class<@Prototype FunctionBinary>[]) FunctionBinary.class.getDeclaredClasses();
117    for (int ii = 0; ii < subclasses.length; ii++) {
118      Class<@Prototype FunctionBinary> subc = subclasses[ii];
119      String function = subc.getName();
120      if (function.indexOf("CLOVER") >= 0) {
121        continue;
122      }
123      function = function.replaceFirst(".*FunctionBinary\\$", "");
124      function = function.replaceFirst("_.*", "");
125      if (function.equals("SubClass")) {
126        continue;
127      }
128      @Prototype FunctionBinary[] fb_arr = functions.get(function);
129      if (fb_arr == null) {
130        fb_arr = new @Prototype FunctionBinary[7];
131        functions.put(function, fb_arr);
132        func_list.add(fb_arr);
133      }
134      int func_id = func_list.indexOf(fb_arr);
135      @SuppressWarnings({"nonprototype"})
136      @Prototype FunctionBinary fb;
137      try {
138        Constructor<@Prototype FunctionBinary> con = subc.getDeclaredConstructor(new Class<?>[] {});
139        fb = con.newInstance(new Object[] {});
140      }  catch (Exception e) {
141        throw new Error(" can't create instance for " + subc.getName()
142                        + ": '" + e + "' ii = " + ii);
143      }
144      assert fb_arr[fb.get_var_order()] == null;
145      fb_arr[fb.get_var_order()] = fb;
146      fb.set_function_id(func_id);
147      debug.fine("Adding " + function + " " + fb.getClass().getName()
148                  + " " + fb.get_var_order() + " " + fb.get_function_id());
149    }
150    ///CLOVER:ON
151  }
152
153  /** Returns a list of all of the FunctionBinary prototype invariants. */
154  public static List<@Prototype Invariant> get_proto_all() {
155
156    List<@Prototype Invariant> result = new ArrayList<>();
157
158    // If this is the first call
159    if (functions.isEmpty()) {
160      build_func_list();
161    }
162
163    // Get the proto invariant for all of the subclasses and return them
164    for (@Prototype FunctionBinary[] fb_arr : func_list) {
165      for (int jj = 1; jj < fb_arr.length; jj++) {
166        @Prototype FunctionBinary fb = fb_arr[jj];
167        if (fb != null) {
168          result.add(fb);
169        }
170      }
171    }
172    return result;
173  }
174
175  /** Permuted result var. */
176  public VarInfo resultVar() {
177    return ppt.var_infos[var_indices[get_var_order()][0]];
178  }
179
180  /** Permuted arg1 var. */
181  public VarInfo argVar1() {
182    return ppt.var_infos[var_indices[get_var_order()][1]];
183  }
184
185  /** Permuted arg2 var. */
186  public VarInfo argVar2() {
187    return ppt.var_infos[var_indices[get_var_order()][2]];
188  }
189
190  /**
191   * Apply the specified sample to the function, returning the result. The caller is responsible
192   * for permuting the arguments.
193   */
194  public InvariantStatus check_ordered(long result, long arg1,
195                                      long arg2, int count) {
196    // This implementation relies on func having no side effects.
197    try {
198      if (!(result == func(arg1, arg2))) {
199        return InvariantStatus.FALSIFIED;
200      }
201    } catch (Exception e) {
202        return InvariantStatus.FALSIFIED;
203    }
204    return InvariantStatus.NO_CHANGE;
205  }
206
207  /**
208   * Apply the specified sample to the function, returning the result. The caller is responsible
209   * for permuting the arguments.
210   */
211  public InvariantStatus add_ordered(long result, long arg1,
212                                      long arg2, int count) {
213    return check_ordered(result, arg1, arg2, count);
214  }
215
216  /**
217   * Reorganize our already-seen state as if the variables had shifted order underneath us
218   * (re-arrangement given by the permutation). We accomplish this by returning the class that
219   * corresponds to the new permutation.
220   */
221  @Override
222  protected Invariant resurrect_done(int[] permutation) {
223
224    assert permutation.length == 3;
225    assert ArraysPlume.fnIsPermutation(permutation);
226
227    int[] new_order = new int[3];
228    int[] old_order = var_indices[get_var_order()];
229
230    // "permutation" is a permutation on the var_info array. old_order
231    // was the permutation that took the formatted invariant to the
232    // var_info array, so old_order^-1 is the permutation from the
233    // var_info array to the old formatted invariant. We want to find
234    // a new_order so that when we first do "permutation", then
235    // apply the new permutation from the var_info array to the
236    // formatted invariant, we get the same formatted invariant.
237    // What we want, then. is:
238    //    new_order^-1 o permutation = old_order^-1
239    // rearranging, this is equivalent to
240    //    new_order = permutation o old_order
241    new_order[0] = permutation[old_order[0]];
242    new_order[1] = permutation[old_order[1]];
243    new_order[2] = permutation[old_order[2]];
244
245    // Force symmetric functions into a canonical form so that
246    // we can match them when necessary and they always print the same.
247    // For example, order of 0, 1, 2 and 0, 2, 1 represent the same
248    // invariant for a symmetric function.  This forces them to always
249    // be represented as 0, 1, 2
250    if (is_symmetric()) {
251      if (new_order[2] < new_order[1]) {
252        int tmp = new_order[2];
253        new_order[2] = new_order[1];
254        new_order[1] = tmp;
255      }
256    }
257
258    // Look for the new order in the list of possible orders
259    int var_order = -1;
260    for (int i = 0; i < var_indices.length; i++) {
261      if (Arrays.equals(new_order, var_indices[i])) {
262        var_order = i;
263        break;
264      }
265    }
266    assert var_order != -1;
267
268    // If the var order hasn't changed, we don't need to do anything
269    if (var_order == get_var_order()) {
270      return this;
271    }
272
273    // Find the class that corresponds to the new order
274    if (functions.isEmpty()) {
275      build_func_list();
276    }
277    int func_id = get_function_id();
278    @Prototype FunctionBinary[] fb_arr = func_list.get(func_id);
279    assert fb_arr != null;
280    for (int ii = 0; ii < fb_arr.length; ii++) {
281      if ((fb_arr[ii] != null) && (fb_arr[ii].get_var_order() == var_order)) {
282        return fb_arr[ii].instantiate_dyn(ppt);
283      }
284    }
285
286    throw new Error("Could not find new ordering");
287  }
288
289  @Override
290  public String repr(@GuardSatisfied FunctionBinary this) {
291    return format();
292  }
293
294  @SideEffectFree
295  @Override
296  public String format_using(@GuardSatisfied FunctionBinary this, OutputFormat format) {
297    if (format == OutputFormat.SIMPLIFY) {
298      return format_simplify();
299    }
300    if (format == OutputFormat.CSHARPCONTRACT) {
301      return format_csharp_contract();
302    }
303
304    int var_order = get_var_order();
305    String[] methodname = get_method_name();
306
307    VarInfo argresultvi = ppt.var_infos[var_indices[var_order][0]];
308    VarInfo arg1vi = ppt.var_infos[var_indices[var_order][1]];
309    VarInfo arg2vi = ppt.var_infos[var_indices[var_order][2]];
310
311    String argresult_name = argresultvi.name_using(format);
312    String arg1_name = arg1vi.name_using(format);
313    String arg2_name = arg2vi.name_using(format);
314
315    if (format == OutputFormat.DAIKON) {
316      return argresult_name + " == (" + methodname[0] + arg1_name
317        + methodname[1] + arg2_name + methodname[2] + ")";
318    }
319
320    if (format.isJavaFamily()) {
321      if (methodname[1].equals(" || ") || methodname[1].equals(" && ")) {
322        return "(" +  argresult_name + " != 0) == ((" + methodname[0] + arg1_name + " != 0)"
323          + methodname[1] + "(" + arg2_name + methodname[2] + " != 0))";
324      } else {
325        return argresult_name + " == (" + methodname[0] + arg1_name
326          + methodname[1] + arg2_name + methodname[2] + ")";
327      }
328    }
329
330    return format_unimplemented(format);
331  }
332
333  public String format_simplify(@GuardSatisfied FunctionBinary this) {
334    int var_order = get_var_order();
335    String[] methodname = get_method_name();
336    VarInfo[] vis = ppt.var_infos;
337
338    String result = vis[var_indices[var_order][0]].simplifyFixedupName();
339    String arg1 = vis[var_indices[var_order][1]].simplifyFixedupName();
340    String arg2 = vis[var_indices[var_order][2]].simplifyFixedupName();
341    String func = null;
342    if (methodname[1].equals(" * ")) {
343      func = "*";
344    } else if (methodname[1].equals(" | ")) {
345      func = "|java-bitwise-or|";
346    } else if (methodname[1].equals(" || ")) {
347      func = "|java-logical-or|";
348    } else if (methodname[1].equals(", ")) {
349      if (methodname[0].equals("java.lang.Math.min(")) {
350        func = "min";
351      } else if (methodname[0].equals("java.lang.Math.max(")) {
352        func = "max";
353      } else if (methodname[0].equals("org.plumelib.util.MathPlume.gcd(")) {
354        func = "gcd";
355      } else if (methodname[0].equals("java.lang.Math.pow(")) {
356        func = "pow";
357      } else if (methodname[0].equals("org.plumelib.util.MathPlume.logicalXor(")) {
358        func = "|java-logical-xor|";
359      }
360    } else {
361      assert methodname[0].equals("");
362      assert methodname[2].equals("");
363      func = "|java-" + methodname[1].trim() + "|";
364    }
365    if (func == null) {
366      return "format_simplify_contract() doesn't know function " + methodname[0] + "-"
367        + methodname[1] + "-" + methodname[2];
368    }
369    return "(EQ " + result + " (" + func + " " + arg1 + " " + arg2 + "))";
370  }
371
372  public String format_csharp_contract(@GuardSatisfied FunctionBinary this) {
373    int var_order = get_var_order();
374    String[] methodname = get_method_name();
375
376    VarInfo argresultvi = ppt.var_infos[var_indices[var_order][0]];
377    VarInfo arg1vi = ppt.var_infos[var_indices[var_order][1]];
378    VarInfo arg2vi = ppt.var_infos[var_indices[var_order][2]];
379    String result = argresultvi.csharp_name();
380    String arg1 = arg1vi.csharp_name();
381    String arg2 = arg2vi.csharp_name();
382    String operator = null;
383
384    if (methodname[1].equals(" * ")) {
385      operator = "*";
386    } else if (methodname[1].equals(" | ")) {
387      operator = "|";
388    } else if (methodname[1].equals(" & ")) {
389      operator = "&";
390    } else if (methodname[1].equals(" / ")) {
391      operator = "/";
392    } else if (methodname[1].equals(" ^ ")) {
393      operator = "^";
394    } else if (methodname[1].equals(" % ")) {
395      operator = "%";
396    } else if (methodname[1].equals(" && ")) {
397      operator = "&&";
398    } else if (methodname[1].equals(" || ")) {
399      operator = "||";
400    } else if (methodname[1].equals(" >> ")) {
401      operator = ">>";
402    } else if (methodname[1].equals(" >>> ")) {
403      return result + " == " + arg1 + ".UnsignedRightShift(" + arg2 + ")";
404      //return result + " == CSharpDaikonLib.Extensions.UnsignedRightShift(" + arg1 + ", " + arg2 + ")";
405    } else if (methodname[1].equals(" << ")) {
406      operator = "<<";
407    }
408
409    if (operator != null) {
410      return result + " == (" + arg1 + " " + operator + " " + arg2 + ")";
411    }
412
413    String func = null;
414    if (methodname[1].equals(", ")) {
415      if (methodname[0].equals("java.lang.Math.min(")) {
416        func = "Math.Min";
417      } else if (methodname[0].equals("java.lang.Math.max(")) {
418        func = "Math.Max";
419      } else if (methodname[0].equals("org.plumelib.util.MathPlume.gcd(")) {
420        return result + " == CSharpDaikonLib.Extensions.GCD(" + arg1 + ", " + arg2 + ")";
421      } else if (methodname[0].equals("java.lang.Math.pow(")) {
422        return result + " == " + arg1 + ".Pow(" + arg2 + ")";
423      } else if (methodname[0].equals("org.plumelib.util.MathPlume.logicalXor(")) {
424        return result + " == (" + arg1 + " ^ " + arg2 + ")";
425      }
426    } else {
427      assert methodname[0].equals("");
428      assert methodname[2].equals("");
429      func = "|" + methodname[1].trim() + "|";
430    }
431
432    if (func == null) {
433      return "format_csharp_contract() doesn't know function " + methodname[0] + "-" + methodname[1] + "-" + methodname[2];
434    }
435    return result + " == " + func + "(" + arg1 + ", " + arg2 + ")";
436  }
437
438  // If our classes match, we must match
439  @Pure
440  @Override
441  public boolean isSameFormula(Invariant other) {
442    return true;
443  }
444  @Override
445  public double computeConfidence() {
446    if (logOn()) {
447      VarInfo v1 = ppt.var_infos[0];
448      VarInfo v2 = ppt.var_infos[1];
449      VarInfo v3 = ppt.var_infos[2];
450      log("computeConfidence(%s: num_values = %s, num_values(%s)=%s, num_values(%s)=%s, num_values(%s)=%s",
451          format(), ppt.num_values(),
452          v1.name(), ppt.parent.num_values(v1),
453          v2.name(), ppt.parent.num_values(v2),
454          v3.name(), ppt.parent.num_values(v3));
455    }
456    return Invariant.conf_is_ge(ppt.num_values(), 5);
457  }
458
459  /** If the arg is a sequence size, return the sequence; otherwise return null. */
460  private @Nullable VarInfo sized_sequence(VarInfo size) {
461    if (size.derived instanceof SequenceLength) {
462      return ((SequenceLength)size.derived).base;
463    }
464    return null;
465  }
466
467  @Pure
468  @Override
469  public @Nullable DiscardInfo isObviousDynamically(VarInfo[] vis) {
470
471    DiscardInfo super_result = super.isObviousDynamically(vis);
472    if (super_result != null) {
473      return super_result;
474    }
475
476    // Discard if any two of the three variables are the sizes of the
477    // same arrays.
478    VarInfo arr1 = sized_sequence(vis[0]);
479    VarInfo arr2 = sized_sequence(vis[1]);
480    VarInfo arr3 = sized_sequence(vis[2]);
481    if (((arr1 != null) && (arr1 == arr2))
482        || ((arr1 != null) && (arr1 == arr3))
483        || ((arr2 != null) && (arr2 == arr3))) {
484      return new DiscardInfo(this, DiscardCode.obvious,
485                    "two are sizes of same array:  "
486                    + vis[0].name() + " "
487                    + vis[1].name() + " "
488                    + vis[2].name());
489    }
490
491    return null;
492  }
493
494  // default is that it is not this function, overriden in the subclass
495  @Pure
496  public boolean isMultiply() {
497    return false;
498  }
499
500/**
501 * Represents the invariant {@code x = Multiply(y, z)} over three long
502 * scalars. 
503 */
504public static class MultiplyLong_xyz extends FunctionBinary {
505  // We are Serializable, so we specify a version to allow changes to
506  // method signatures without breaking serialization.  If you add or
507  // remove fields, you should change this number to the current date.
508  static final long serialVersionUID = 20031030L;
509
510  private static @Prototype MultiplyLong_xyz proto = new @Prototype MultiplyLong_xyz ();
511
512  /** Returns the prototype invariant for MultiplyLong_xyz */
513  public static @Prototype MultiplyLong_xyz get_proto() {
514    return proto;
515  }
516
517  /** instantiate an invariant on the specified slice */
518  @Override
519  protected MultiplyLong_xyz instantiate_dyn(@Prototype MultiplyLong_xyz this, PptSlice slice) {
520    return new MultiplyLong_xyz (slice);
521  }
522
523  private MultiplyLong_xyz (PptSlice slice) {
524    super(slice);
525  }
526
527  public @Prototype MultiplyLong_xyz () {
528    super();
529  }
530
531  private static String[] method_name = new String[] {"", " * ", ""};
532
533  @Override
534  public String[] get_method_name(@GuardSatisfied MultiplyLong_xyz this) {
535    return method_name;
536  }
537
538  private static int function_id = -1;
539
540  @Override
541  public int get_function_id() {
542    return function_id;
543  }
544
545  @Override
546  public void set_function_id(int function_id) {
547    assert MultiplyLong_xyz.function_id == -1;
548    MultiplyLong_xyz.function_id = function_id;
549  }
550
551  private static int var_order = 1;
552
553  @Override
554  public int get_var_order(@GuardSatisfied MultiplyLong_xyz this) {
555    return var_order;
556  }
557
558  @Pure
559  @Override
560  public boolean is_symmetric() {
561
562      return true;
563  }
564
565  @Override
566
567  public long func(long y, long z) {
568
569    return y * z;
570  }
571
572  @Override
573  public InvariantStatus check_modified(long x, long y,
574                                      long z, int count) {
575    return check_ordered(x, y, z, count);
576  }
577
578  @Override
579  public InvariantStatus add_modified(long x, long y,
580                                      long z, int count) {
581    if (Debug.logDetail()) {
582      log("result=%s, arg1=%s, arg2=%s", x, y, z);
583    }
584    return add_ordered(x, y, z, count);
585  }
586
587  @Pure
588  @Override
589  public boolean isMultiply() {
590    return true;
591  }
592
593  @Pure
594  @Override
595  public boolean isExact() {
596    return true;
597  }
598
599  /** Returns a list of non-instantiating suppressions for this invariant. */
600  @Pure
601  @Override
602  public @Nullable NISuppressionSet get_ni_suppressions() {
603    if (NIS.dkconfig_enabled && dkconfig_enabled) {
604      return suppressions;
605    } else {
606      return null;
607    }
608  }
609
610  /** definition of this invariant (the suppressee) */
611  private static NISuppressee suppressee = new NISuppressee(MultiplyLong_xyz.class, 3);
612
613  // suppressor definitions (used below)
614  private static NISuppressor result_eq_arg1 =
615      new NISuppressor(0, 1, IntEqual.class);
616  private static NISuppressor result_eq_arg2 =
617      new NISuppressor(0, 2, IntEqual.class);
618  private static NISuppressor arg1_eq_arg2 =
619      new NISuppressor(1, 2, IntEqual.class);
620
621  private static NISuppressor result_lt_arg1 =
622      new NISuppressor(0, 1, IntLessThan.class);
623  private static NISuppressor result_lt_arg2 =
624      new NISuppressor(0, 2, IntLessThan.class);
625  private static NISuppressor arg1_lt_arg2 =
626      new NISuppressor(1, 2, IntLessThan.class);
627  private static NISuppressor arg2_lt_arg1 =
628      new NISuppressor(2, 1, IntLessThan.class);
629
630  private static NISuppressor result_le_arg1 =
631      new NISuppressor(0, 1, IntLessEqual.class);
632  private static NISuppressor result_le_arg2 =
633      new NISuppressor(0, 2, IntLessEqual.class);
634  private static NISuppressor arg1_le_arg2 =
635      new NISuppressor(1, 2, IntLessEqual.class);
636  private static NISuppressor arg2_le_arg1 =
637      new NISuppressor(2, 1, IntLessEqual.class);
638
639  private static NISuppressor result_track0_arg1 =
640      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
641  private static NISuppressor result_track0_arg2 =
642      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
643  private static NISuppressor arg1_track0_arg2 =
644      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
645  private static NISuppressor arg1_track0_result =
646      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
647  private static NISuppressor arg2_track0_result =
648      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
649  private static NISuppressor arg2_track0_arg1 =
650      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
651
652  private static NISuppressor result_eq_1 =
653      new NISuppressor(0, RangeInt.EqualOne.class);
654  private static NISuppressor arg1_eq_1 =
655      new NISuppressor(1, RangeInt.EqualOne.class);
656  private static NISuppressor arg2_eq_1 =
657      new NISuppressor(2, RangeInt.EqualOne.class);
658
659  private static NISuppressor result_eq_0 =
660      new NISuppressor(0, RangeInt.EqualZero.class);
661  private static NISuppressor arg1_eq_0 =
662      new NISuppressor(1, RangeInt.EqualZero.class);
663  private static NISuppressor arg2_eq_0 =
664      new NISuppressor(2, RangeInt.EqualZero.class);
665
666  private static NISuppressor result_ne_0 =
667      new NISuppressor(0, NonZero.class);
668  private static NISuppressor arg1_ne_0 =
669      new NISuppressor(1, NonZero.class);
670  private static NISuppressor arg2_ne_0 =
671      new NISuppressor(2, NonZero.class);
672
673  private static NISuppressor result_ge_0 =
674      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
675  private static NISuppressor arg1_ge_0 =
676      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
677  private static NISuppressor arg2_ge_0 =
678      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
679
680  private static NISuppressor result_ge_64 =
681      new NISuppressor(0, RangeInt.GreaterEqual64.class);
682  private static NISuppressor arg1_ge_64 =
683      new NISuppressor(1, RangeInt.GreaterEqual64.class);
684  private static NISuppressor arg2_ge_64 =
685      new NISuppressor(2, RangeInt.GreaterEqual64.class);
686
687  private static NISuppressor result_boolean =
688      new NISuppressor(0, RangeInt.BooleanVal.class);
689  private static NISuppressor arg1_boolean =
690      new NISuppressor(1, RangeInt.BooleanVal.class);
691  private static NISuppressor arg2_boolean =
692      new NISuppressor(2, RangeInt.BooleanVal.class);
693
694  private static NISuppressor result_even =
695      new NISuppressor(0, RangeInt.Even.class);
696  private static NISuppressor arg1_even =
697      new NISuppressor(1, RangeInt.Even.class);
698  private static NISuppressor arg2_even =
699      new NISuppressor(2, RangeInt.Even.class);
700
701  private static NISuppressor result_power2 =
702      new NISuppressor(0, RangeInt.PowerOfTwo.class);
703  private static NISuppressor arg1_power2 =
704      new NISuppressor(1, RangeInt.PowerOfTwo.class);
705  private static NISuppressor arg2_power2 =
706      new NISuppressor(2, RangeInt.PowerOfTwo.class);
707
708  private static NISuppressor result_and0_arg1 =
709      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
710  private static NISuppressor result_and0_arg2 =
711      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
712  private static NISuppressor arg1_and0_arg2 =
713      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
714
715  // The arguments to bitwise subset are backwards from what one
716  // might expect.  The second argument is a subset of the first
717  // argument
718  private static NISuppressor arg1_bw_subset_arg2 =
719      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
720  private static NISuppressor arg2_bw_subset_arg1 =
721      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
722
723  private static NISuppressor result_shift0_arg1 =
724      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
725  private static NISuppressor result_shift0_arg2 =
726      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
727  private static NISuppressor arg1_shift0_arg2 =
728      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
729
730  private static NISuppressor arg2_divides_arg1 =
731      new NISuppressor(1, 2, NumericInt.Divides.class);
732  private static NISuppressor arg1_divides_arg2 =
733      new NISuppressor(2, 1, NumericInt.Divides.class);
734
735  private static NISuppressor arg2_valid_shift =
736      new NISuppressor(2, RangeInt.Bound0_63.class);
737
738    private static NISuppressionSet suppressions =
739      new NISuppressionSet(
740          new NISuppression[] {
741
742            // (r == 0) && (y == 0) ==> r = y * z
743            new NISuppression(result_eq_0, arg1_eq_0, suppressee),
744
745            // (r == 0) && (z == 0) ==> r = y * z
746            new NISuppression(result_eq_0, arg2_eq_0, suppressee),
747
748            // (r == y) && (z == 1) ==> r = y * z
749            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
750
751            // (r == z) && (y == 1) ==> r = y * z
752            new NISuppression(result_eq_arg2, arg1_eq_1, suppressee),
753
754            // (r == y) && (z boolean) && (z==0 ==> y==0)
755            // x = x * 0 is true if x == 0
756            // x = x * 1 is true for all x
757            new NISuppression(arg2_boolean, arg2_track0_arg1, result_eq_arg1,
758                               suppressee),
759
760            // (r == z) && (y boolean) && (y==0 ==> z=0)
761            new NISuppression(result_eq_arg2, arg1_track0_arg2, arg1_boolean,
762                               suppressee),
763
764          });
765
766  // Create a suppression factory for functionBinary
767
768}
769
770/**
771 * Represents the invariant {@code y = Multiply(x, z)} over three long
772 * scalars. 
773 */
774public static class MultiplyLong_yxz extends FunctionBinary {
775  // We are Serializable, so we specify a version to allow changes to
776  // method signatures without breaking serialization.  If you add or
777  // remove fields, you should change this number to the current date.
778  static final long serialVersionUID = 20031030L;
779
780  private static @Prototype MultiplyLong_yxz proto = new @Prototype MultiplyLong_yxz ();
781
782  /** Returns the prototype invariant for MultiplyLong_yxz */
783  public static @Prototype MultiplyLong_yxz get_proto() {
784    return proto;
785  }
786
787  /** instantiate an invariant on the specified slice */
788  @Override
789  protected MultiplyLong_yxz instantiate_dyn(@Prototype MultiplyLong_yxz this, PptSlice slice) {
790    return new MultiplyLong_yxz (slice);
791  }
792
793  private MultiplyLong_yxz (PptSlice slice) {
794    super(slice);
795  }
796
797  public @Prototype MultiplyLong_yxz () {
798    super();
799  }
800
801  private static String[] method_name = new String[] {"", " * ", ""};
802
803  @Override
804  public String[] get_method_name(@GuardSatisfied MultiplyLong_yxz this) {
805    return method_name;
806  }
807
808  private static int function_id = -1;
809
810  @Override
811  public int get_function_id() {
812    return function_id;
813  }
814
815  @Override
816  public void set_function_id(int function_id) {
817    assert MultiplyLong_yxz.function_id == -1;
818    MultiplyLong_yxz.function_id = function_id;
819  }
820
821  private static int var_order = 2;
822
823  @Override
824  public int get_var_order(@GuardSatisfied MultiplyLong_yxz this) {
825    return var_order;
826  }
827
828  @Pure
829  @Override
830  public boolean is_symmetric() {
831
832      return true;
833  }
834
835  @Override
836
837  public long func(long x, long z) {
838
839    return x * z;
840  }
841
842  @Override
843  public InvariantStatus check_modified(long x, long y,
844                                      long z, int count) {
845    return check_ordered(y, x, z, count);
846  }
847
848  @Override
849  public InvariantStatus add_modified(long x, long y,
850                                      long z, int count) {
851    if (Debug.logDetail()) {
852      log("result=%s, arg1=%s, arg2=%s", y, x, z);
853    }
854    return add_ordered(y, x, z, count);
855  }
856
857  @Pure
858  @Override
859  public boolean isMultiply() {
860    return true;
861  }
862
863  @Pure
864  @Override
865  public boolean isExact() {
866    return true;
867  }
868
869  /** Returns a list of non-instantiating suppressions for this invariant. */
870  @Pure
871  @Override
872  public @Nullable NISuppressionSet get_ni_suppressions() {
873    if (NIS.dkconfig_enabled && dkconfig_enabled) {
874      return suppressions;
875    } else {
876      return null;
877    }
878  }
879
880  /** definition of this invariant (the suppressee) */
881  private static NISuppressee suppressee = new NISuppressee(MultiplyLong_yxz.class, 3);
882
883  // suppressor definitions (used below)
884  private static NISuppressor result_eq_arg1 =
885      new NISuppressor(1, 0, IntEqual.class);
886  private static NISuppressor result_eq_arg2 =
887      new NISuppressor(1, 2, IntEqual.class);
888  private static NISuppressor arg1_eq_arg2 =
889      new NISuppressor(0, 2, IntEqual.class);
890
891  private static NISuppressor result_lt_arg1 =
892      new NISuppressor(1, 0, IntLessThan.class);
893  private static NISuppressor result_lt_arg2 =
894      new NISuppressor(1, 2, IntLessThan.class);
895  private static NISuppressor arg1_lt_arg2 =
896      new NISuppressor(0, 2, IntLessThan.class);
897  private static NISuppressor arg2_lt_arg1 =
898      new NISuppressor(2, 0, IntLessThan.class);
899
900  private static NISuppressor result_le_arg1 =
901      new NISuppressor(1, 0, IntLessEqual.class);
902  private static NISuppressor result_le_arg2 =
903      new NISuppressor(1, 2, IntLessEqual.class);
904  private static NISuppressor arg1_le_arg2 =
905      new NISuppressor(0, 2, IntLessEqual.class);
906  private static NISuppressor arg2_le_arg1 =
907      new NISuppressor(2, 0, IntLessEqual.class);
908
909  private static NISuppressor result_track0_arg1 =
910      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
911  private static NISuppressor result_track0_arg2 =
912      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
913  private static NISuppressor arg1_track0_arg2 =
914      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
915  private static NISuppressor arg1_track0_result =
916      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
917  private static NISuppressor arg2_track0_result =
918      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
919  private static NISuppressor arg2_track0_arg1 =
920      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
921
922  private static NISuppressor result_eq_1 =
923      new NISuppressor(1, RangeInt.EqualOne.class);
924  private static NISuppressor arg1_eq_1 =
925      new NISuppressor(0, RangeInt.EqualOne.class);
926  private static NISuppressor arg2_eq_1 =
927      new NISuppressor(2, RangeInt.EqualOne.class);
928
929  private static NISuppressor result_eq_0 =
930      new NISuppressor(1, RangeInt.EqualZero.class);
931  private static NISuppressor arg1_eq_0 =
932      new NISuppressor(0, RangeInt.EqualZero.class);
933  private static NISuppressor arg2_eq_0 =
934      new NISuppressor(2, RangeInt.EqualZero.class);
935
936  private static NISuppressor result_ne_0 =
937      new NISuppressor(1, NonZero.class);
938  private static NISuppressor arg1_ne_0 =
939      new NISuppressor(0, NonZero.class);
940  private static NISuppressor arg2_ne_0 =
941      new NISuppressor(2, NonZero.class);
942
943  private static NISuppressor result_ge_0 =
944      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
945  private static NISuppressor arg1_ge_0 =
946      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
947  private static NISuppressor arg2_ge_0 =
948      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
949
950  private static NISuppressor result_ge_64 =
951      new NISuppressor(1, RangeInt.GreaterEqual64.class);
952  private static NISuppressor arg1_ge_64 =
953      new NISuppressor(0, RangeInt.GreaterEqual64.class);
954  private static NISuppressor arg2_ge_64 =
955      new NISuppressor(2, RangeInt.GreaterEqual64.class);
956
957  private static NISuppressor result_boolean =
958      new NISuppressor(1, RangeInt.BooleanVal.class);
959  private static NISuppressor arg1_boolean =
960      new NISuppressor(0, RangeInt.BooleanVal.class);
961  private static NISuppressor arg2_boolean =
962      new NISuppressor(2, RangeInt.BooleanVal.class);
963
964  private static NISuppressor result_even =
965      new NISuppressor(1, RangeInt.Even.class);
966  private static NISuppressor arg1_even =
967      new NISuppressor(0, RangeInt.Even.class);
968  private static NISuppressor arg2_even =
969      new NISuppressor(2, RangeInt.Even.class);
970
971  private static NISuppressor result_power2 =
972      new NISuppressor(1, RangeInt.PowerOfTwo.class);
973  private static NISuppressor arg1_power2 =
974      new NISuppressor(0, RangeInt.PowerOfTwo.class);
975  private static NISuppressor arg2_power2 =
976      new NISuppressor(2, RangeInt.PowerOfTwo.class);
977
978  private static NISuppressor result_and0_arg1 =
979      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
980  private static NISuppressor result_and0_arg2 =
981      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
982  private static NISuppressor arg1_and0_arg2 =
983      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
984
985  // The arguments to bitwise subset are backwards from what one
986  // might expect.  The second argument is a subset of the first
987  // argument
988  private static NISuppressor arg1_bw_subset_arg2 =
989      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
990  private static NISuppressor arg2_bw_subset_arg1 =
991      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
992
993  private static NISuppressor result_shift0_arg1 =
994      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
995  private static NISuppressor result_shift0_arg2 =
996      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
997  private static NISuppressor arg1_shift0_arg2 =
998      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
999
1000  private static NISuppressor arg2_divides_arg1 =
1001      new NISuppressor(0, 2, NumericInt.Divides.class);
1002  private static NISuppressor arg1_divides_arg2 =
1003      new NISuppressor(2, 0, NumericInt.Divides.class);
1004
1005  private static NISuppressor arg2_valid_shift =
1006      new NISuppressor(2, RangeInt.Bound0_63.class);
1007
1008    private static NISuppressionSet suppressions =
1009      new NISuppressionSet(
1010          new NISuppression[] {
1011
1012            // (r == 0) && (x == 0) ==> r = x * z
1013            new NISuppression(result_eq_0, arg1_eq_0, suppressee),
1014
1015            // (r == 0) && (z == 0) ==> r = x * z
1016            new NISuppression(result_eq_0, arg2_eq_0, suppressee),
1017
1018            // (r == x) && (z == 1) ==> r = x * z
1019            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
1020
1021            // (r == z) && (x == 1) ==> r = x * z
1022            new NISuppression(result_eq_arg2, arg1_eq_1, suppressee),
1023
1024            // (r == x) && (z boolean) && (z==0 ==> x==0)
1025            // x = x * 0 is true if x == 0
1026            // x = x * 1 is true for all x
1027            new NISuppression(arg2_boolean, arg2_track0_arg1, result_eq_arg1,
1028                               suppressee),
1029
1030            // (r == z) && (x boolean) && (x==0 ==> z=0)
1031            new NISuppression(result_eq_arg2, arg1_track0_arg2, arg1_boolean,
1032                               suppressee),
1033
1034          });
1035
1036  // Create a suppression factory for functionBinary
1037
1038}
1039
1040/**
1041 * Represents the invariant {@code z = Multiply(x, y)} over three long
1042 * scalars. 
1043 */
1044public static class MultiplyLong_zxy extends FunctionBinary {
1045  // We are Serializable, so we specify a version to allow changes to
1046  // method signatures without breaking serialization.  If you add or
1047  // remove fields, you should change this number to the current date.
1048  static final long serialVersionUID = 20031030L;
1049
1050  private static @Prototype MultiplyLong_zxy proto = new @Prototype MultiplyLong_zxy ();
1051
1052  /** Returns the prototype invariant for MultiplyLong_zxy */
1053  public static @Prototype MultiplyLong_zxy get_proto() {
1054    return proto;
1055  }
1056
1057  /** instantiate an invariant on the specified slice */
1058  @Override
1059  protected MultiplyLong_zxy instantiate_dyn(@Prototype MultiplyLong_zxy this, PptSlice slice) {
1060    return new MultiplyLong_zxy (slice);
1061  }
1062
1063  private MultiplyLong_zxy (PptSlice slice) {
1064    super(slice);
1065  }
1066
1067  public @Prototype MultiplyLong_zxy () {
1068    super();
1069  }
1070
1071  private static String[] method_name = new String[] {"", " * ", ""};
1072
1073  @Override
1074  public String[] get_method_name(@GuardSatisfied MultiplyLong_zxy this) {
1075    return method_name;
1076  }
1077
1078  private static int function_id = -1;
1079
1080  @Override
1081  public int get_function_id() {
1082    return function_id;
1083  }
1084
1085  @Override
1086  public void set_function_id(int function_id) {
1087    assert MultiplyLong_zxy.function_id == -1;
1088    MultiplyLong_zxy.function_id = function_id;
1089  }
1090
1091  private static int var_order = 3;
1092
1093  @Override
1094  public int get_var_order(@GuardSatisfied MultiplyLong_zxy this) {
1095    return var_order;
1096  }
1097
1098  @Pure
1099  @Override
1100  public boolean is_symmetric() {
1101
1102      return true;
1103  }
1104
1105  @Override
1106
1107  public long func(long x, long y) {
1108
1109    return x * y;
1110  }
1111
1112  @Override
1113  public InvariantStatus check_modified(long x, long y,
1114                                      long z, int count) {
1115    return check_ordered(z, x, y, count);
1116  }
1117
1118  @Override
1119  public InvariantStatus add_modified(long x, long y,
1120                                      long z, int count) {
1121    if (Debug.logDetail()) {
1122      log("result=%s, arg1=%s, arg2=%s", z, x, y);
1123    }
1124    return add_ordered(z, x, y, count);
1125  }
1126
1127  @Pure
1128  @Override
1129  public boolean isMultiply() {
1130    return true;
1131  }
1132
1133  @Pure
1134  @Override
1135  public boolean isExact() {
1136    return true;
1137  }
1138
1139  /** Returns a list of non-instantiating suppressions for this invariant. */
1140  @Pure
1141  @Override
1142  public @Nullable NISuppressionSet get_ni_suppressions() {
1143    if (NIS.dkconfig_enabled && dkconfig_enabled) {
1144      return suppressions;
1145    } else {
1146      return null;
1147    }
1148  }
1149
1150  /** definition of this invariant (the suppressee) */
1151  private static NISuppressee suppressee = new NISuppressee(MultiplyLong_zxy.class, 3);
1152
1153  // suppressor definitions (used below)
1154  private static NISuppressor result_eq_arg1 =
1155      new NISuppressor(2, 0, IntEqual.class);
1156  private static NISuppressor result_eq_arg2 =
1157      new NISuppressor(2, 1, IntEqual.class);
1158  private static NISuppressor arg1_eq_arg2 =
1159      new NISuppressor(0, 1, IntEqual.class);
1160
1161  private static NISuppressor result_lt_arg1 =
1162      new NISuppressor(2, 0, IntLessThan.class);
1163  private static NISuppressor result_lt_arg2 =
1164      new NISuppressor(2, 1, IntLessThan.class);
1165  private static NISuppressor arg1_lt_arg2 =
1166      new NISuppressor(0, 1, IntLessThan.class);
1167  private static NISuppressor arg2_lt_arg1 =
1168      new NISuppressor(1, 0, IntLessThan.class);
1169
1170  private static NISuppressor result_le_arg1 =
1171      new NISuppressor(2, 0, IntLessEqual.class);
1172  private static NISuppressor result_le_arg2 =
1173      new NISuppressor(2, 1, IntLessEqual.class);
1174  private static NISuppressor arg1_le_arg2 =
1175      new NISuppressor(0, 1, IntLessEqual.class);
1176  private static NISuppressor arg2_le_arg1 =
1177      new NISuppressor(1, 0, IntLessEqual.class);
1178
1179  private static NISuppressor result_track0_arg1 =
1180      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
1181  private static NISuppressor result_track0_arg2 =
1182      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
1183  private static NISuppressor arg1_track0_arg2 =
1184      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
1185  private static NISuppressor arg1_track0_result =
1186      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
1187  private static NISuppressor arg2_track0_result =
1188      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
1189  private static NISuppressor arg2_track0_arg1 =
1190      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
1191
1192  private static NISuppressor result_eq_1 =
1193      new NISuppressor(2, RangeInt.EqualOne.class);
1194  private static NISuppressor arg1_eq_1 =
1195      new NISuppressor(0, RangeInt.EqualOne.class);
1196  private static NISuppressor arg2_eq_1 =
1197      new NISuppressor(1, RangeInt.EqualOne.class);
1198
1199  private static NISuppressor result_eq_0 =
1200      new NISuppressor(2, RangeInt.EqualZero.class);
1201  private static NISuppressor arg1_eq_0 =
1202      new NISuppressor(0, RangeInt.EqualZero.class);
1203  private static NISuppressor arg2_eq_0 =
1204      new NISuppressor(1, RangeInt.EqualZero.class);
1205
1206  private static NISuppressor result_ne_0 =
1207      new NISuppressor(2, NonZero.class);
1208  private static NISuppressor arg1_ne_0 =
1209      new NISuppressor(0, NonZero.class);
1210  private static NISuppressor arg2_ne_0 =
1211      new NISuppressor(1, NonZero.class);
1212
1213  private static NISuppressor result_ge_0 =
1214      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
1215  private static NISuppressor arg1_ge_0 =
1216      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
1217  private static NISuppressor arg2_ge_0 =
1218      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
1219
1220  private static NISuppressor result_ge_64 =
1221      new NISuppressor(2, RangeInt.GreaterEqual64.class);
1222  private static NISuppressor arg1_ge_64 =
1223      new NISuppressor(0, RangeInt.GreaterEqual64.class);
1224  private static NISuppressor arg2_ge_64 =
1225      new NISuppressor(1, RangeInt.GreaterEqual64.class);
1226
1227  private static NISuppressor result_boolean =
1228      new NISuppressor(2, RangeInt.BooleanVal.class);
1229  private static NISuppressor arg1_boolean =
1230      new NISuppressor(0, RangeInt.BooleanVal.class);
1231  private static NISuppressor arg2_boolean =
1232      new NISuppressor(1, RangeInt.BooleanVal.class);
1233
1234  private static NISuppressor result_even =
1235      new NISuppressor(2, RangeInt.Even.class);
1236  private static NISuppressor arg1_even =
1237      new NISuppressor(0, RangeInt.Even.class);
1238  private static NISuppressor arg2_even =
1239      new NISuppressor(1, RangeInt.Even.class);
1240
1241  private static NISuppressor result_power2 =
1242      new NISuppressor(2, RangeInt.PowerOfTwo.class);
1243  private static NISuppressor arg1_power2 =
1244      new NISuppressor(0, RangeInt.PowerOfTwo.class);
1245  private static NISuppressor arg2_power2 =
1246      new NISuppressor(1, RangeInt.PowerOfTwo.class);
1247
1248  private static NISuppressor result_and0_arg1 =
1249      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
1250  private static NISuppressor result_and0_arg2 =
1251      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
1252  private static NISuppressor arg1_and0_arg2 =
1253      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
1254
1255  // The arguments to bitwise subset are backwards from what one
1256  // might expect.  The second argument is a subset of the first
1257  // argument
1258  private static NISuppressor arg1_bw_subset_arg2 =
1259      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
1260  private static NISuppressor arg2_bw_subset_arg1 =
1261      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
1262
1263  private static NISuppressor result_shift0_arg1 =
1264      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
1265  private static NISuppressor result_shift0_arg2 =
1266      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
1267  private static NISuppressor arg1_shift0_arg2 =
1268      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
1269
1270  private static NISuppressor arg2_divides_arg1 =
1271      new NISuppressor(0, 1, NumericInt.Divides.class);
1272  private static NISuppressor arg1_divides_arg2 =
1273      new NISuppressor(1, 0, NumericInt.Divides.class);
1274
1275  private static NISuppressor arg2_valid_shift =
1276      new NISuppressor(1, RangeInt.Bound0_63.class);
1277
1278    private static NISuppressionSet suppressions =
1279      new NISuppressionSet(
1280          new NISuppression[] {
1281
1282            // (r == 0) && (x == 0) ==> r = x * y
1283            new NISuppression(result_eq_0, arg1_eq_0, suppressee),
1284
1285            // (r == 0) && (y == 0) ==> r = x * y
1286            new NISuppression(result_eq_0, arg2_eq_0, suppressee),
1287
1288            // (r == x) && (y == 1) ==> r = x * y
1289            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
1290
1291            // (r == y) && (x == 1) ==> r = x * y
1292            new NISuppression(result_eq_arg2, arg1_eq_1, suppressee),
1293
1294            // (r == x) && (y boolean) && (y==0 ==> x==0)
1295            // x = x * 0 is true if x == 0
1296            // x = x * 1 is true for all x
1297            new NISuppression(arg2_boolean, arg2_track0_arg1, result_eq_arg1,
1298                               suppressee),
1299
1300            // (r == y) && (x boolean) && (x==0 ==> y=0)
1301            new NISuppression(result_eq_arg2, arg1_track0_arg2, arg1_boolean,
1302                               suppressee),
1303
1304          });
1305
1306  // Create a suppression factory for functionBinary
1307
1308}
1309
1310  // #define EQUALITY_MIN_MAX_SUPPRESS
1311
1312  // default is that it is not this function, overriden in the subclass
1313  @Pure
1314  public boolean isMinimum() {
1315    return false;
1316  }
1317
1318/**
1319 * Represents the invariant {@code x = Minimum(y, z)} over three long
1320 * scalars. 
1321 */
1322public static class MinimumLong_xyz extends FunctionBinary {
1323  // We are Serializable, so we specify a version to allow changes to
1324  // method signatures without breaking serialization.  If you add or
1325  // remove fields, you should change this number to the current date.
1326  static final long serialVersionUID = 20031030L;
1327
1328  private static @Prototype MinimumLong_xyz proto = new @Prototype MinimumLong_xyz ();
1329
1330  /** Returns the prototype invariant for MinimumLong_xyz */
1331  public static @Prototype MinimumLong_xyz get_proto() {
1332    return proto;
1333  }
1334
1335  /** instantiate an invariant on the specified slice */
1336  @Override
1337  protected MinimumLong_xyz instantiate_dyn(@Prototype MinimumLong_xyz this, PptSlice slice) {
1338    return new MinimumLong_xyz (slice);
1339  }
1340
1341  private MinimumLong_xyz (PptSlice slice) {
1342    super(slice);
1343  }
1344
1345  public @Prototype MinimumLong_xyz () {
1346    super();
1347  }
1348
1349  private static String[] method_name = new String[] {"java.lang.Math.min(", ", ", ")"};
1350
1351  @Override
1352  public String[] get_method_name(@GuardSatisfied MinimumLong_xyz this) {
1353    return method_name;
1354  }
1355
1356  private static int function_id = -1;
1357
1358  @Override
1359  public int get_function_id() {
1360    return function_id;
1361  }
1362
1363  @Override
1364  public void set_function_id(int function_id) {
1365    assert MinimumLong_xyz.function_id == -1;
1366    MinimumLong_xyz.function_id = function_id;
1367  }
1368
1369  private static int var_order = 1;
1370
1371  @Override
1372  public int get_var_order(@GuardSatisfied MinimumLong_xyz this) {
1373    return var_order;
1374  }
1375
1376  @Pure
1377  @Override
1378  public boolean is_symmetric() {
1379
1380      return true;
1381  }
1382
1383  @Override
1384
1385  public long func(long y, long z) {
1386
1387    return Math.min(y, z);
1388  }
1389
1390  @Override
1391  public InvariantStatus check_modified(long x, long y,
1392                                      long z, int count) {
1393    return check_ordered(x, y, z, count);
1394  }
1395
1396  @Override
1397  public InvariantStatus add_modified(long x, long y,
1398                                      long z, int count) {
1399    if (Debug.logDetail()) {
1400      log("result=%s, arg1=%s, arg2=%s", x, y, z);
1401    }
1402    return add_ordered(x, y, z, count);
1403  }
1404
1405  @Pure
1406  @Override
1407  public boolean isMinimum() {
1408    return true;
1409  }
1410
1411  /** Returns a list of non-instantiating suppressions for this invariant. */
1412  @Pure
1413  @Override
1414  public @Nullable NISuppressionSet get_ni_suppressions() {
1415    if (NIS.dkconfig_enabled && dkconfig_enabled) {
1416      return suppressions;
1417    } else {
1418      return null;
1419    }
1420  }
1421
1422  /** definition of this invariant (the suppressee) */
1423  private static NISuppressee suppressee = new NISuppressee(MinimumLong_xyz.class, 3);
1424
1425  // suppressor definitions (used below)
1426  private static NISuppressor result_eq_arg1 =
1427      new NISuppressor(0, 1, IntEqual.class);
1428  private static NISuppressor result_eq_arg2 =
1429      new NISuppressor(0, 2, IntEqual.class);
1430  private static NISuppressor arg1_eq_arg2 =
1431      new NISuppressor(1, 2, IntEqual.class);
1432
1433  private static NISuppressor result_lt_arg1 =
1434      new NISuppressor(0, 1, IntLessThan.class);
1435  private static NISuppressor result_lt_arg2 =
1436      new NISuppressor(0, 2, IntLessThan.class);
1437  private static NISuppressor arg1_lt_arg2 =
1438      new NISuppressor(1, 2, IntLessThan.class);
1439  private static NISuppressor arg2_lt_arg1 =
1440      new NISuppressor(2, 1, IntLessThan.class);
1441
1442  private static NISuppressor result_le_arg1 =
1443      new NISuppressor(0, 1, IntLessEqual.class);
1444  private static NISuppressor result_le_arg2 =
1445      new NISuppressor(0, 2, IntLessEqual.class);
1446  private static NISuppressor arg1_le_arg2 =
1447      new NISuppressor(1, 2, IntLessEqual.class);
1448  private static NISuppressor arg2_le_arg1 =
1449      new NISuppressor(2, 1, IntLessEqual.class);
1450
1451  private static NISuppressor result_track0_arg1 =
1452      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
1453  private static NISuppressor result_track0_arg2 =
1454      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
1455  private static NISuppressor arg1_track0_arg2 =
1456      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
1457  private static NISuppressor arg1_track0_result =
1458      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
1459  private static NISuppressor arg2_track0_result =
1460      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
1461  private static NISuppressor arg2_track0_arg1 =
1462      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
1463
1464  private static NISuppressor result_eq_1 =
1465      new NISuppressor(0, RangeInt.EqualOne.class);
1466  private static NISuppressor arg1_eq_1 =
1467      new NISuppressor(1, RangeInt.EqualOne.class);
1468  private static NISuppressor arg2_eq_1 =
1469      new NISuppressor(2, RangeInt.EqualOne.class);
1470
1471  private static NISuppressor result_eq_0 =
1472      new NISuppressor(0, RangeInt.EqualZero.class);
1473  private static NISuppressor arg1_eq_0 =
1474      new NISuppressor(1, RangeInt.EqualZero.class);
1475  private static NISuppressor arg2_eq_0 =
1476      new NISuppressor(2, RangeInt.EqualZero.class);
1477
1478  private static NISuppressor result_ne_0 =
1479      new NISuppressor(0, NonZero.class);
1480  private static NISuppressor arg1_ne_0 =
1481      new NISuppressor(1, NonZero.class);
1482  private static NISuppressor arg2_ne_0 =
1483      new NISuppressor(2, NonZero.class);
1484
1485  private static NISuppressor result_ge_0 =
1486      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
1487  private static NISuppressor arg1_ge_0 =
1488      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
1489  private static NISuppressor arg2_ge_0 =
1490      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
1491
1492  private static NISuppressor result_ge_64 =
1493      new NISuppressor(0, RangeInt.GreaterEqual64.class);
1494  private static NISuppressor arg1_ge_64 =
1495      new NISuppressor(1, RangeInt.GreaterEqual64.class);
1496  private static NISuppressor arg2_ge_64 =
1497      new NISuppressor(2, RangeInt.GreaterEqual64.class);
1498
1499  private static NISuppressor result_boolean =
1500      new NISuppressor(0, RangeInt.BooleanVal.class);
1501  private static NISuppressor arg1_boolean =
1502      new NISuppressor(1, RangeInt.BooleanVal.class);
1503  private static NISuppressor arg2_boolean =
1504      new NISuppressor(2, RangeInt.BooleanVal.class);
1505
1506  private static NISuppressor result_even =
1507      new NISuppressor(0, RangeInt.Even.class);
1508  private static NISuppressor arg1_even =
1509      new NISuppressor(1, RangeInt.Even.class);
1510  private static NISuppressor arg2_even =
1511      new NISuppressor(2, RangeInt.Even.class);
1512
1513  private static NISuppressor result_power2 =
1514      new NISuppressor(0, RangeInt.PowerOfTwo.class);
1515  private static NISuppressor arg1_power2 =
1516      new NISuppressor(1, RangeInt.PowerOfTwo.class);
1517  private static NISuppressor arg2_power2 =
1518      new NISuppressor(2, RangeInt.PowerOfTwo.class);
1519
1520  private static NISuppressor result_and0_arg1 =
1521      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
1522  private static NISuppressor result_and0_arg2 =
1523      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
1524  private static NISuppressor arg1_and0_arg2 =
1525      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
1526
1527  // The arguments to bitwise subset are backwards from what one
1528  // might expect.  The second argument is a subset of the first
1529  // argument
1530  private static NISuppressor arg1_bw_subset_arg2 =
1531      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
1532  private static NISuppressor arg2_bw_subset_arg1 =
1533      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
1534
1535  private static NISuppressor result_shift0_arg1 =
1536      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
1537  private static NISuppressor result_shift0_arg2 =
1538      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
1539  private static NISuppressor arg1_shift0_arg2 =
1540      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
1541
1542  private static NISuppressor arg2_divides_arg1 =
1543      new NISuppressor(1, 2, NumericInt.Divides.class);
1544  private static NISuppressor arg1_divides_arg2 =
1545      new NISuppressor(2, 1, NumericInt.Divides.class);
1546
1547  private static NISuppressor arg2_valid_shift =
1548      new NISuppressor(2, RangeInt.Bound0_63.class);
1549
1550    private static NISuppressionSet suppressions =
1551      new NISuppressionSet(
1552          new NISuppression[] {
1553
1554            // (x == y) && (y <= z) ==> r = min(y, z)
1555            new NISuppression(result_eq_arg1, arg1_le_arg2, suppressee),
1556
1557            // (x == z) && (z <= y) ==> r = min(y, z)
1558            new NISuppression(result_eq_arg2, arg2_le_arg1, suppressee),
1559
1560            // (x boolean) && (y=0 <==> r=0) && (z == 1)
1561            // 0 = min (y, 1), true when (y == 0)
1562            // 1 = min (y, 1), true when (y > 0)
1563            new NISuppression(result_track0_arg1, arg1_track0_result,
1564                               result_boolean, arg1_ge_0, arg2_eq_1, suppressee),
1565
1566            // (x boolean) && (z=0 <==> r=0) && (y == 1)
1567            new NISuppression(result_track0_arg2, arg2_track0_result,
1568                               result_boolean, arg2_ge_0, arg1_eq_1, suppressee),
1569
1570          });
1571
1572  // Create a suppression factory for functionBinary
1573
1574}
1575
1576/**
1577 * Represents the invariant {@code y = Minimum(x, z)} over three long
1578 * scalars. 
1579 */
1580public static class MinimumLong_yxz extends FunctionBinary {
1581  // We are Serializable, so we specify a version to allow changes to
1582  // method signatures without breaking serialization.  If you add or
1583  // remove fields, you should change this number to the current date.
1584  static final long serialVersionUID = 20031030L;
1585
1586  private static @Prototype MinimumLong_yxz proto = new @Prototype MinimumLong_yxz ();
1587
1588  /** Returns the prototype invariant for MinimumLong_yxz */
1589  public static @Prototype MinimumLong_yxz get_proto() {
1590    return proto;
1591  }
1592
1593  /** instantiate an invariant on the specified slice */
1594  @Override
1595  protected MinimumLong_yxz instantiate_dyn(@Prototype MinimumLong_yxz this, PptSlice slice) {
1596    return new MinimumLong_yxz (slice);
1597  }
1598
1599  private MinimumLong_yxz (PptSlice slice) {
1600    super(slice);
1601  }
1602
1603  public @Prototype MinimumLong_yxz () {
1604    super();
1605  }
1606
1607  private static String[] method_name = new String[] {"java.lang.Math.min(", ", ", ")"};
1608
1609  @Override
1610  public String[] get_method_name(@GuardSatisfied MinimumLong_yxz this) {
1611    return method_name;
1612  }
1613
1614  private static int function_id = -1;
1615
1616  @Override
1617  public int get_function_id() {
1618    return function_id;
1619  }
1620
1621  @Override
1622  public void set_function_id(int function_id) {
1623    assert MinimumLong_yxz.function_id == -1;
1624    MinimumLong_yxz.function_id = function_id;
1625  }
1626
1627  private static int var_order = 2;
1628
1629  @Override
1630  public int get_var_order(@GuardSatisfied MinimumLong_yxz this) {
1631    return var_order;
1632  }
1633
1634  @Pure
1635  @Override
1636  public boolean is_symmetric() {
1637
1638      return true;
1639  }
1640
1641  @Override
1642
1643  public long func(long x, long z) {
1644
1645    return Math.min(x, z);
1646  }
1647
1648  @Override
1649  public InvariantStatus check_modified(long x, long y,
1650                                      long z, int count) {
1651    return check_ordered(y, x, z, count);
1652  }
1653
1654  @Override
1655  public InvariantStatus add_modified(long x, long y,
1656                                      long z, int count) {
1657    if (Debug.logDetail()) {
1658      log("result=%s, arg1=%s, arg2=%s", y, x, z);
1659    }
1660    return add_ordered(y, x, z, count);
1661  }
1662
1663  @Pure
1664  @Override
1665  public boolean isMinimum() {
1666    return true;
1667  }
1668
1669  /** Returns a list of non-instantiating suppressions for this invariant. */
1670  @Pure
1671  @Override
1672  public @Nullable NISuppressionSet get_ni_suppressions() {
1673    if (NIS.dkconfig_enabled && dkconfig_enabled) {
1674      return suppressions;
1675    } else {
1676      return null;
1677    }
1678  }
1679
1680  /** definition of this invariant (the suppressee) */
1681  private static NISuppressee suppressee = new NISuppressee(MinimumLong_yxz.class, 3);
1682
1683  // suppressor definitions (used below)
1684  private static NISuppressor result_eq_arg1 =
1685      new NISuppressor(1, 0, IntEqual.class);
1686  private static NISuppressor result_eq_arg2 =
1687      new NISuppressor(1, 2, IntEqual.class);
1688  private static NISuppressor arg1_eq_arg2 =
1689      new NISuppressor(0, 2, IntEqual.class);
1690
1691  private static NISuppressor result_lt_arg1 =
1692      new NISuppressor(1, 0, IntLessThan.class);
1693  private static NISuppressor result_lt_arg2 =
1694      new NISuppressor(1, 2, IntLessThan.class);
1695  private static NISuppressor arg1_lt_arg2 =
1696      new NISuppressor(0, 2, IntLessThan.class);
1697  private static NISuppressor arg2_lt_arg1 =
1698      new NISuppressor(2, 0, IntLessThan.class);
1699
1700  private static NISuppressor result_le_arg1 =
1701      new NISuppressor(1, 0, IntLessEqual.class);
1702  private static NISuppressor result_le_arg2 =
1703      new NISuppressor(1, 2, IntLessEqual.class);
1704  private static NISuppressor arg1_le_arg2 =
1705      new NISuppressor(0, 2, IntLessEqual.class);
1706  private static NISuppressor arg2_le_arg1 =
1707      new NISuppressor(2, 0, IntLessEqual.class);
1708
1709  private static NISuppressor result_track0_arg1 =
1710      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
1711  private static NISuppressor result_track0_arg2 =
1712      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
1713  private static NISuppressor arg1_track0_arg2 =
1714      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
1715  private static NISuppressor arg1_track0_result =
1716      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
1717  private static NISuppressor arg2_track0_result =
1718      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
1719  private static NISuppressor arg2_track0_arg1 =
1720      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
1721
1722  private static NISuppressor result_eq_1 =
1723      new NISuppressor(1, RangeInt.EqualOne.class);
1724  private static NISuppressor arg1_eq_1 =
1725      new NISuppressor(0, RangeInt.EqualOne.class);
1726  private static NISuppressor arg2_eq_1 =
1727      new NISuppressor(2, RangeInt.EqualOne.class);
1728
1729  private static NISuppressor result_eq_0 =
1730      new NISuppressor(1, RangeInt.EqualZero.class);
1731  private static NISuppressor arg1_eq_0 =
1732      new NISuppressor(0, RangeInt.EqualZero.class);
1733  private static NISuppressor arg2_eq_0 =
1734      new NISuppressor(2, RangeInt.EqualZero.class);
1735
1736  private static NISuppressor result_ne_0 =
1737      new NISuppressor(1, NonZero.class);
1738  private static NISuppressor arg1_ne_0 =
1739      new NISuppressor(0, NonZero.class);
1740  private static NISuppressor arg2_ne_0 =
1741      new NISuppressor(2, NonZero.class);
1742
1743  private static NISuppressor result_ge_0 =
1744      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
1745  private static NISuppressor arg1_ge_0 =
1746      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
1747  private static NISuppressor arg2_ge_0 =
1748      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
1749
1750  private static NISuppressor result_ge_64 =
1751      new NISuppressor(1, RangeInt.GreaterEqual64.class);
1752  private static NISuppressor arg1_ge_64 =
1753      new NISuppressor(0, RangeInt.GreaterEqual64.class);
1754  private static NISuppressor arg2_ge_64 =
1755      new NISuppressor(2, RangeInt.GreaterEqual64.class);
1756
1757  private static NISuppressor result_boolean =
1758      new NISuppressor(1, RangeInt.BooleanVal.class);
1759  private static NISuppressor arg1_boolean =
1760      new NISuppressor(0, RangeInt.BooleanVal.class);
1761  private static NISuppressor arg2_boolean =
1762      new NISuppressor(2, RangeInt.BooleanVal.class);
1763
1764  private static NISuppressor result_even =
1765      new NISuppressor(1, RangeInt.Even.class);
1766  private static NISuppressor arg1_even =
1767      new NISuppressor(0, RangeInt.Even.class);
1768  private static NISuppressor arg2_even =
1769      new NISuppressor(2, RangeInt.Even.class);
1770
1771  private static NISuppressor result_power2 =
1772      new NISuppressor(1, RangeInt.PowerOfTwo.class);
1773  private static NISuppressor arg1_power2 =
1774      new NISuppressor(0, RangeInt.PowerOfTwo.class);
1775  private static NISuppressor arg2_power2 =
1776      new NISuppressor(2, RangeInt.PowerOfTwo.class);
1777
1778  private static NISuppressor result_and0_arg1 =
1779      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
1780  private static NISuppressor result_and0_arg2 =
1781      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
1782  private static NISuppressor arg1_and0_arg2 =
1783      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
1784
1785  // The arguments to bitwise subset are backwards from what one
1786  // might expect.  The second argument is a subset of the first
1787  // argument
1788  private static NISuppressor arg1_bw_subset_arg2 =
1789      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
1790  private static NISuppressor arg2_bw_subset_arg1 =
1791      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
1792
1793  private static NISuppressor result_shift0_arg1 =
1794      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
1795  private static NISuppressor result_shift0_arg2 =
1796      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
1797  private static NISuppressor arg1_shift0_arg2 =
1798      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
1799
1800  private static NISuppressor arg2_divides_arg1 =
1801      new NISuppressor(0, 2, NumericInt.Divides.class);
1802  private static NISuppressor arg1_divides_arg2 =
1803      new NISuppressor(2, 0, NumericInt.Divides.class);
1804
1805  private static NISuppressor arg2_valid_shift =
1806      new NISuppressor(2, RangeInt.Bound0_63.class);
1807
1808    private static NISuppressionSet suppressions =
1809      new NISuppressionSet(
1810          new NISuppression[] {
1811
1812            // (y == x) && (x <= z) ==> r = min(x, z)
1813            new NISuppression(result_eq_arg1, arg1_le_arg2, suppressee),
1814
1815            // (y == z) && (z <= x) ==> r = min(x, z)
1816            new NISuppression(result_eq_arg2, arg2_le_arg1, suppressee),
1817
1818            // (y boolean) && (x=0 <==> r=0) && (z == 1)
1819            // 0 = min (x, 1), true when (x == 0)
1820            // 1 = min (x, 1), true when (x > 0)
1821            new NISuppression(result_track0_arg1, arg1_track0_result,
1822                               result_boolean, arg1_ge_0, arg2_eq_1, suppressee),
1823
1824            // (y boolean) && (z=0 <==> r=0) && (x == 1)
1825            new NISuppression(result_track0_arg2, arg2_track0_result,
1826                               result_boolean, arg2_ge_0, arg1_eq_1, suppressee),
1827
1828          });
1829
1830  // Create a suppression factory for functionBinary
1831
1832}
1833
1834/**
1835 * Represents the invariant {@code z = Minimum(x, y)} over three long
1836 * scalars. 
1837 */
1838public static class MinimumLong_zxy extends FunctionBinary {
1839  // We are Serializable, so we specify a version to allow changes to
1840  // method signatures without breaking serialization.  If you add or
1841  // remove fields, you should change this number to the current date.
1842  static final long serialVersionUID = 20031030L;
1843
1844  private static @Prototype MinimumLong_zxy proto = new @Prototype MinimumLong_zxy ();
1845
1846  /** Returns the prototype invariant for MinimumLong_zxy */
1847  public static @Prototype MinimumLong_zxy get_proto() {
1848    return proto;
1849  }
1850
1851  /** instantiate an invariant on the specified slice */
1852  @Override
1853  protected MinimumLong_zxy instantiate_dyn(@Prototype MinimumLong_zxy this, PptSlice slice) {
1854    return new MinimumLong_zxy (slice);
1855  }
1856
1857  private MinimumLong_zxy (PptSlice slice) {
1858    super(slice);
1859  }
1860
1861  public @Prototype MinimumLong_zxy () {
1862    super();
1863  }
1864
1865  private static String[] method_name = new String[] {"java.lang.Math.min(", ", ", ")"};
1866
1867  @Override
1868  public String[] get_method_name(@GuardSatisfied MinimumLong_zxy this) {
1869    return method_name;
1870  }
1871
1872  private static int function_id = -1;
1873
1874  @Override
1875  public int get_function_id() {
1876    return function_id;
1877  }
1878
1879  @Override
1880  public void set_function_id(int function_id) {
1881    assert MinimumLong_zxy.function_id == -1;
1882    MinimumLong_zxy.function_id = function_id;
1883  }
1884
1885  private static int var_order = 3;
1886
1887  @Override
1888  public int get_var_order(@GuardSatisfied MinimumLong_zxy this) {
1889    return var_order;
1890  }
1891
1892  @Pure
1893  @Override
1894  public boolean is_symmetric() {
1895
1896      return true;
1897  }
1898
1899  @Override
1900
1901  public long func(long x, long y) {
1902
1903    return Math.min(x, y);
1904  }
1905
1906  @Override
1907  public InvariantStatus check_modified(long x, long y,
1908                                      long z, int count) {
1909    return check_ordered(z, x, y, count);
1910  }
1911
1912  @Override
1913  public InvariantStatus add_modified(long x, long y,
1914                                      long z, int count) {
1915    if (Debug.logDetail()) {
1916      log("result=%s, arg1=%s, arg2=%s", z, x, y);
1917    }
1918    return add_ordered(z, x, y, count);
1919  }
1920
1921  @Pure
1922  @Override
1923  public boolean isMinimum() {
1924    return true;
1925  }
1926
1927  /** Returns a list of non-instantiating suppressions for this invariant. */
1928  @Pure
1929  @Override
1930  public @Nullable NISuppressionSet get_ni_suppressions() {
1931    if (NIS.dkconfig_enabled && dkconfig_enabled) {
1932      return suppressions;
1933    } else {
1934      return null;
1935    }
1936  }
1937
1938  /** definition of this invariant (the suppressee) */
1939  private static NISuppressee suppressee = new NISuppressee(MinimumLong_zxy.class, 3);
1940
1941  // suppressor definitions (used below)
1942  private static NISuppressor result_eq_arg1 =
1943      new NISuppressor(2, 0, IntEqual.class);
1944  private static NISuppressor result_eq_arg2 =
1945      new NISuppressor(2, 1, IntEqual.class);
1946  private static NISuppressor arg1_eq_arg2 =
1947      new NISuppressor(0, 1, IntEqual.class);
1948
1949  private static NISuppressor result_lt_arg1 =
1950      new NISuppressor(2, 0, IntLessThan.class);
1951  private static NISuppressor result_lt_arg2 =
1952      new NISuppressor(2, 1, IntLessThan.class);
1953  private static NISuppressor arg1_lt_arg2 =
1954      new NISuppressor(0, 1, IntLessThan.class);
1955  private static NISuppressor arg2_lt_arg1 =
1956      new NISuppressor(1, 0, IntLessThan.class);
1957
1958  private static NISuppressor result_le_arg1 =
1959      new NISuppressor(2, 0, IntLessEqual.class);
1960  private static NISuppressor result_le_arg2 =
1961      new NISuppressor(2, 1, IntLessEqual.class);
1962  private static NISuppressor arg1_le_arg2 =
1963      new NISuppressor(0, 1, IntLessEqual.class);
1964  private static NISuppressor arg2_le_arg1 =
1965      new NISuppressor(1, 0, IntLessEqual.class);
1966
1967  private static NISuppressor result_track0_arg1 =
1968      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
1969  private static NISuppressor result_track0_arg2 =
1970      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
1971  private static NISuppressor arg1_track0_arg2 =
1972      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
1973  private static NISuppressor arg1_track0_result =
1974      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
1975  private static NISuppressor arg2_track0_result =
1976      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
1977  private static NISuppressor arg2_track0_arg1 =
1978      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
1979
1980  private static NISuppressor result_eq_1 =
1981      new NISuppressor(2, RangeInt.EqualOne.class);
1982  private static NISuppressor arg1_eq_1 =
1983      new NISuppressor(0, RangeInt.EqualOne.class);
1984  private static NISuppressor arg2_eq_1 =
1985      new NISuppressor(1, RangeInt.EqualOne.class);
1986
1987  private static NISuppressor result_eq_0 =
1988      new NISuppressor(2, RangeInt.EqualZero.class);
1989  private static NISuppressor arg1_eq_0 =
1990      new NISuppressor(0, RangeInt.EqualZero.class);
1991  private static NISuppressor arg2_eq_0 =
1992      new NISuppressor(1, RangeInt.EqualZero.class);
1993
1994  private static NISuppressor result_ne_0 =
1995      new NISuppressor(2, NonZero.class);
1996  private static NISuppressor arg1_ne_0 =
1997      new NISuppressor(0, NonZero.class);
1998  private static NISuppressor arg2_ne_0 =
1999      new NISuppressor(1, NonZero.class);
2000
2001  private static NISuppressor result_ge_0 =
2002      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
2003  private static NISuppressor arg1_ge_0 =
2004      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
2005  private static NISuppressor arg2_ge_0 =
2006      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
2007
2008  private static NISuppressor result_ge_64 =
2009      new NISuppressor(2, RangeInt.GreaterEqual64.class);
2010  private static NISuppressor arg1_ge_64 =
2011      new NISuppressor(0, RangeInt.GreaterEqual64.class);
2012  private static NISuppressor arg2_ge_64 =
2013      new NISuppressor(1, RangeInt.GreaterEqual64.class);
2014
2015  private static NISuppressor result_boolean =
2016      new NISuppressor(2, RangeInt.BooleanVal.class);
2017  private static NISuppressor arg1_boolean =
2018      new NISuppressor(0, RangeInt.BooleanVal.class);
2019  private static NISuppressor arg2_boolean =
2020      new NISuppressor(1, RangeInt.BooleanVal.class);
2021
2022  private static NISuppressor result_even =
2023      new NISuppressor(2, RangeInt.Even.class);
2024  private static NISuppressor arg1_even =
2025      new NISuppressor(0, RangeInt.Even.class);
2026  private static NISuppressor arg2_even =
2027      new NISuppressor(1, RangeInt.Even.class);
2028
2029  private static NISuppressor result_power2 =
2030      new NISuppressor(2, RangeInt.PowerOfTwo.class);
2031  private static NISuppressor arg1_power2 =
2032      new NISuppressor(0, RangeInt.PowerOfTwo.class);
2033  private static NISuppressor arg2_power2 =
2034      new NISuppressor(1, RangeInt.PowerOfTwo.class);
2035
2036  private static NISuppressor result_and0_arg1 =
2037      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
2038  private static NISuppressor result_and0_arg2 =
2039      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
2040  private static NISuppressor arg1_and0_arg2 =
2041      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
2042
2043  // The arguments to bitwise subset are backwards from what one
2044  // might expect.  The second argument is a subset of the first
2045  // argument
2046  private static NISuppressor arg1_bw_subset_arg2 =
2047      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
2048  private static NISuppressor arg2_bw_subset_arg1 =
2049      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
2050
2051  private static NISuppressor result_shift0_arg1 =
2052      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
2053  private static NISuppressor result_shift0_arg2 =
2054      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
2055  private static NISuppressor arg1_shift0_arg2 =
2056      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
2057
2058  private static NISuppressor arg2_divides_arg1 =
2059      new NISuppressor(0, 1, NumericInt.Divides.class);
2060  private static NISuppressor arg1_divides_arg2 =
2061      new NISuppressor(1, 0, NumericInt.Divides.class);
2062
2063  private static NISuppressor arg2_valid_shift =
2064      new NISuppressor(1, RangeInt.Bound0_63.class);
2065
2066    private static NISuppressionSet suppressions =
2067      new NISuppressionSet(
2068          new NISuppression[] {
2069
2070            // (z == x) && (x <= y) ==> r = min(x, y)
2071            new NISuppression(result_eq_arg1, arg1_le_arg2, suppressee),
2072
2073            // (z == y) && (y <= x) ==> r = min(x, y)
2074            new NISuppression(result_eq_arg2, arg2_le_arg1, suppressee),
2075
2076            // (z boolean) && (x=0 <==> r=0) && (y == 1)
2077            // 0 = min (x, 1), true when (x == 0)
2078            // 1 = min (x, 1), true when (x > 0)
2079            new NISuppression(result_track0_arg1, arg1_track0_result,
2080                               result_boolean, arg1_ge_0, arg2_eq_1, suppressee),
2081
2082            // (z boolean) && (y=0 <==> r=0) && (x == 1)
2083            new NISuppression(result_track0_arg2, arg2_track0_result,
2084                               result_boolean, arg2_ge_0, arg1_eq_1, suppressee),
2085
2086          });
2087
2088  // Create a suppression factory for functionBinary
2089
2090}
2091
2092  // #define EQUALITY_MIN_MAX_SUPPRESS
2093
2094  // default is that it is not this function, overriden in the subclass
2095  @Pure
2096  public boolean isMaximum() {
2097    return false;
2098  }
2099
2100/**
2101 * Represents the invariant {@code x = Maximum(y, z)} over three long
2102 * scalars. 
2103 */
2104public static class MaximumLong_xyz extends FunctionBinary {
2105  // We are Serializable, so we specify a version to allow changes to
2106  // method signatures without breaking serialization.  If you add or
2107  // remove fields, you should change this number to the current date.
2108  static final long serialVersionUID = 20031030L;
2109
2110  private static @Prototype MaximumLong_xyz proto = new @Prototype MaximumLong_xyz ();
2111
2112  /** Returns the prototype invariant for MaximumLong_xyz */
2113  public static @Prototype MaximumLong_xyz get_proto() {
2114    return proto;
2115  }
2116
2117  /** instantiate an invariant on the specified slice */
2118  @Override
2119  protected MaximumLong_xyz instantiate_dyn(@Prototype MaximumLong_xyz this, PptSlice slice) {
2120    return new MaximumLong_xyz (slice);
2121  }
2122
2123  private MaximumLong_xyz (PptSlice slice) {
2124    super(slice);
2125  }
2126
2127  public @Prototype MaximumLong_xyz () {
2128    super();
2129  }
2130
2131  private static String[] method_name = new String[] {"java.lang.Math.max(", ", ", ")"};
2132
2133  @Override
2134  public String[] get_method_name(@GuardSatisfied MaximumLong_xyz this) {
2135    return method_name;
2136  }
2137
2138  private static int function_id = -1;
2139
2140  @Override
2141  public int get_function_id() {
2142    return function_id;
2143  }
2144
2145  @Override
2146  public void set_function_id(int function_id) {
2147    assert MaximumLong_xyz.function_id == -1;
2148    MaximumLong_xyz.function_id = function_id;
2149  }
2150
2151  private static int var_order = 1;
2152
2153  @Override
2154  public int get_var_order(@GuardSatisfied MaximumLong_xyz this) {
2155    return var_order;
2156  }
2157
2158  @Pure
2159  @Override
2160  public boolean is_symmetric() {
2161
2162      return true;
2163  }
2164
2165  @Override
2166
2167  public long func(long y, long z) {
2168
2169    return Math.max(y, z);
2170  }
2171
2172  @Override
2173  public InvariantStatus check_modified(long x, long y,
2174                                      long z, int count) {
2175    return check_ordered(x, y, z, count);
2176  }
2177
2178  @Override
2179  public InvariantStatus add_modified(long x, long y,
2180                                      long z, int count) {
2181    if (Debug.logDetail()) {
2182      log("result=%s, arg1=%s, arg2=%s", x, y, z);
2183    }
2184    return add_ordered(x, y, z, count);
2185  }
2186
2187  @Pure
2188  @Override
2189  public boolean isMaximum() {
2190    return true;
2191  }
2192
2193  /** Returns a list of non-instantiating suppressions for this invariant. */
2194  @Pure
2195  @Override
2196  public @Nullable NISuppressionSet get_ni_suppressions() {
2197    if (NIS.dkconfig_enabled && dkconfig_enabled) {
2198      return suppressions;
2199    } else {
2200      return null;
2201    }
2202  }
2203
2204  /** definition of this invariant (the suppressee) */
2205  private static NISuppressee suppressee = new NISuppressee(MaximumLong_xyz.class, 3);
2206
2207  // suppressor definitions (used below)
2208  private static NISuppressor result_eq_arg1 =
2209      new NISuppressor(0, 1, IntEqual.class);
2210  private static NISuppressor result_eq_arg2 =
2211      new NISuppressor(0, 2, IntEqual.class);
2212  private static NISuppressor arg1_eq_arg2 =
2213      new NISuppressor(1, 2, IntEqual.class);
2214
2215  private static NISuppressor result_lt_arg1 =
2216      new NISuppressor(0, 1, IntLessThan.class);
2217  private static NISuppressor result_lt_arg2 =
2218      new NISuppressor(0, 2, IntLessThan.class);
2219  private static NISuppressor arg1_lt_arg2 =
2220      new NISuppressor(1, 2, IntLessThan.class);
2221  private static NISuppressor arg2_lt_arg1 =
2222      new NISuppressor(2, 1, IntLessThan.class);
2223
2224  private static NISuppressor result_le_arg1 =
2225      new NISuppressor(0, 1, IntLessEqual.class);
2226  private static NISuppressor result_le_arg2 =
2227      new NISuppressor(0, 2, IntLessEqual.class);
2228  private static NISuppressor arg1_le_arg2 =
2229      new NISuppressor(1, 2, IntLessEqual.class);
2230  private static NISuppressor arg2_le_arg1 =
2231      new NISuppressor(2, 1, IntLessEqual.class);
2232
2233  private static NISuppressor result_track0_arg1 =
2234      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
2235  private static NISuppressor result_track0_arg2 =
2236      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
2237  private static NISuppressor arg1_track0_arg2 =
2238      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
2239  private static NISuppressor arg1_track0_result =
2240      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
2241  private static NISuppressor arg2_track0_result =
2242      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
2243  private static NISuppressor arg2_track0_arg1 =
2244      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
2245
2246  private static NISuppressor result_eq_1 =
2247      new NISuppressor(0, RangeInt.EqualOne.class);
2248  private static NISuppressor arg1_eq_1 =
2249      new NISuppressor(1, RangeInt.EqualOne.class);
2250  private static NISuppressor arg2_eq_1 =
2251      new NISuppressor(2, RangeInt.EqualOne.class);
2252
2253  private static NISuppressor result_eq_0 =
2254      new NISuppressor(0, RangeInt.EqualZero.class);
2255  private static NISuppressor arg1_eq_0 =
2256      new NISuppressor(1, RangeInt.EqualZero.class);
2257  private static NISuppressor arg2_eq_0 =
2258      new NISuppressor(2, RangeInt.EqualZero.class);
2259
2260  private static NISuppressor result_ne_0 =
2261      new NISuppressor(0, NonZero.class);
2262  private static NISuppressor arg1_ne_0 =
2263      new NISuppressor(1, NonZero.class);
2264  private static NISuppressor arg2_ne_0 =
2265      new NISuppressor(2, NonZero.class);
2266
2267  private static NISuppressor result_ge_0 =
2268      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
2269  private static NISuppressor arg1_ge_0 =
2270      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
2271  private static NISuppressor arg2_ge_0 =
2272      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
2273
2274  private static NISuppressor result_ge_64 =
2275      new NISuppressor(0, RangeInt.GreaterEqual64.class);
2276  private static NISuppressor arg1_ge_64 =
2277      new NISuppressor(1, RangeInt.GreaterEqual64.class);
2278  private static NISuppressor arg2_ge_64 =
2279      new NISuppressor(2, RangeInt.GreaterEqual64.class);
2280
2281  private static NISuppressor result_boolean =
2282      new NISuppressor(0, RangeInt.BooleanVal.class);
2283  private static NISuppressor arg1_boolean =
2284      new NISuppressor(1, RangeInt.BooleanVal.class);
2285  private static NISuppressor arg2_boolean =
2286      new NISuppressor(2, RangeInt.BooleanVal.class);
2287
2288  private static NISuppressor result_even =
2289      new NISuppressor(0, RangeInt.Even.class);
2290  private static NISuppressor arg1_even =
2291      new NISuppressor(1, RangeInt.Even.class);
2292  private static NISuppressor arg2_even =
2293      new NISuppressor(2, RangeInt.Even.class);
2294
2295  private static NISuppressor result_power2 =
2296      new NISuppressor(0, RangeInt.PowerOfTwo.class);
2297  private static NISuppressor arg1_power2 =
2298      new NISuppressor(1, RangeInt.PowerOfTwo.class);
2299  private static NISuppressor arg2_power2 =
2300      new NISuppressor(2, RangeInt.PowerOfTwo.class);
2301
2302  private static NISuppressor result_and0_arg1 =
2303      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
2304  private static NISuppressor result_and0_arg2 =
2305      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
2306  private static NISuppressor arg1_and0_arg2 =
2307      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
2308
2309  // The arguments to bitwise subset are backwards from what one
2310  // might expect.  The second argument is a subset of the first
2311  // argument
2312  private static NISuppressor arg1_bw_subset_arg2 =
2313      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
2314  private static NISuppressor arg2_bw_subset_arg1 =
2315      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
2316
2317  private static NISuppressor result_shift0_arg1 =
2318      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
2319  private static NISuppressor result_shift0_arg2 =
2320      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
2321  private static NISuppressor arg1_shift0_arg2 =
2322      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
2323
2324  private static NISuppressor arg2_divides_arg1 =
2325      new NISuppressor(1, 2, NumericInt.Divides.class);
2326  private static NISuppressor arg1_divides_arg2 =
2327      new NISuppressor(2, 1, NumericInt.Divides.class);
2328
2329  private static NISuppressor arg2_valid_shift =
2330      new NISuppressor(2, RangeInt.Bound0_63.class);
2331
2332    private static NISuppressionSet suppressions =
2333      new NISuppressionSet(
2334          new NISuppression[] {
2335
2336            // (r == y) && (z <= y) ==> r = max(y, z)
2337            new NISuppression(result_eq_arg1, arg2_le_arg1, suppressee),
2338
2339            // (r == z) && (y <= z) ==> r = max(y, z)
2340            new NISuppression(result_eq_arg2, arg1_le_arg2, suppressee),
2341
2342          });
2343
2344  // Create a suppression factory for functionBinary
2345
2346}
2347
2348/**
2349 * Represents the invariant {@code y = Maximum(x, z)} over three long
2350 * scalars. 
2351 */
2352public static class MaximumLong_yxz extends FunctionBinary {
2353  // We are Serializable, so we specify a version to allow changes to
2354  // method signatures without breaking serialization.  If you add or
2355  // remove fields, you should change this number to the current date.
2356  static final long serialVersionUID = 20031030L;
2357
2358  private static @Prototype MaximumLong_yxz proto = new @Prototype MaximumLong_yxz ();
2359
2360  /** Returns the prototype invariant for MaximumLong_yxz */
2361  public static @Prototype MaximumLong_yxz get_proto() {
2362    return proto;
2363  }
2364
2365  /** instantiate an invariant on the specified slice */
2366  @Override
2367  protected MaximumLong_yxz instantiate_dyn(@Prototype MaximumLong_yxz this, PptSlice slice) {
2368    return new MaximumLong_yxz (slice);
2369  }
2370
2371  private MaximumLong_yxz (PptSlice slice) {
2372    super(slice);
2373  }
2374
2375  public @Prototype MaximumLong_yxz () {
2376    super();
2377  }
2378
2379  private static String[] method_name = new String[] {"java.lang.Math.max(", ", ", ")"};
2380
2381  @Override
2382  public String[] get_method_name(@GuardSatisfied MaximumLong_yxz this) {
2383    return method_name;
2384  }
2385
2386  private static int function_id = -1;
2387
2388  @Override
2389  public int get_function_id() {
2390    return function_id;
2391  }
2392
2393  @Override
2394  public void set_function_id(int function_id) {
2395    assert MaximumLong_yxz.function_id == -1;
2396    MaximumLong_yxz.function_id = function_id;
2397  }
2398
2399  private static int var_order = 2;
2400
2401  @Override
2402  public int get_var_order(@GuardSatisfied MaximumLong_yxz this) {
2403    return var_order;
2404  }
2405
2406  @Pure
2407  @Override
2408  public boolean is_symmetric() {
2409
2410      return true;
2411  }
2412
2413  @Override
2414
2415  public long func(long x, long z) {
2416
2417    return Math.max(x, z);
2418  }
2419
2420  @Override
2421  public InvariantStatus check_modified(long x, long y,
2422                                      long z, int count) {
2423    return check_ordered(y, x, z, count);
2424  }
2425
2426  @Override
2427  public InvariantStatus add_modified(long x, long y,
2428                                      long z, int count) {
2429    if (Debug.logDetail()) {
2430      log("result=%s, arg1=%s, arg2=%s", y, x, z);
2431    }
2432    return add_ordered(y, x, z, count);
2433  }
2434
2435  @Pure
2436  @Override
2437  public boolean isMaximum() {
2438    return true;
2439  }
2440
2441  /** Returns a list of non-instantiating suppressions for this invariant. */
2442  @Pure
2443  @Override
2444  public @Nullable NISuppressionSet get_ni_suppressions() {
2445    if (NIS.dkconfig_enabled && dkconfig_enabled) {
2446      return suppressions;
2447    } else {
2448      return null;
2449    }
2450  }
2451
2452  /** definition of this invariant (the suppressee) */
2453  private static NISuppressee suppressee = new NISuppressee(MaximumLong_yxz.class, 3);
2454
2455  // suppressor definitions (used below)
2456  private static NISuppressor result_eq_arg1 =
2457      new NISuppressor(1, 0, IntEqual.class);
2458  private static NISuppressor result_eq_arg2 =
2459      new NISuppressor(1, 2, IntEqual.class);
2460  private static NISuppressor arg1_eq_arg2 =
2461      new NISuppressor(0, 2, IntEqual.class);
2462
2463  private static NISuppressor result_lt_arg1 =
2464      new NISuppressor(1, 0, IntLessThan.class);
2465  private static NISuppressor result_lt_arg2 =
2466      new NISuppressor(1, 2, IntLessThan.class);
2467  private static NISuppressor arg1_lt_arg2 =
2468      new NISuppressor(0, 2, IntLessThan.class);
2469  private static NISuppressor arg2_lt_arg1 =
2470      new NISuppressor(2, 0, IntLessThan.class);
2471
2472  private static NISuppressor result_le_arg1 =
2473      new NISuppressor(1, 0, IntLessEqual.class);
2474  private static NISuppressor result_le_arg2 =
2475      new NISuppressor(1, 2, IntLessEqual.class);
2476  private static NISuppressor arg1_le_arg2 =
2477      new NISuppressor(0, 2, IntLessEqual.class);
2478  private static NISuppressor arg2_le_arg1 =
2479      new NISuppressor(2, 0, IntLessEqual.class);
2480
2481  private static NISuppressor result_track0_arg1 =
2482      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
2483  private static NISuppressor result_track0_arg2 =
2484      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
2485  private static NISuppressor arg1_track0_arg2 =
2486      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
2487  private static NISuppressor arg1_track0_result =
2488      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
2489  private static NISuppressor arg2_track0_result =
2490      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
2491  private static NISuppressor arg2_track0_arg1 =
2492      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
2493
2494  private static NISuppressor result_eq_1 =
2495      new NISuppressor(1, RangeInt.EqualOne.class);
2496  private static NISuppressor arg1_eq_1 =
2497      new NISuppressor(0, RangeInt.EqualOne.class);
2498  private static NISuppressor arg2_eq_1 =
2499      new NISuppressor(2, RangeInt.EqualOne.class);
2500
2501  private static NISuppressor result_eq_0 =
2502      new NISuppressor(1, RangeInt.EqualZero.class);
2503  private static NISuppressor arg1_eq_0 =
2504      new NISuppressor(0, RangeInt.EqualZero.class);
2505  private static NISuppressor arg2_eq_0 =
2506      new NISuppressor(2, RangeInt.EqualZero.class);
2507
2508  private static NISuppressor result_ne_0 =
2509      new NISuppressor(1, NonZero.class);
2510  private static NISuppressor arg1_ne_0 =
2511      new NISuppressor(0, NonZero.class);
2512  private static NISuppressor arg2_ne_0 =
2513      new NISuppressor(2, NonZero.class);
2514
2515  private static NISuppressor result_ge_0 =
2516      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
2517  private static NISuppressor arg1_ge_0 =
2518      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
2519  private static NISuppressor arg2_ge_0 =
2520      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
2521
2522  private static NISuppressor result_ge_64 =
2523      new NISuppressor(1, RangeInt.GreaterEqual64.class);
2524  private static NISuppressor arg1_ge_64 =
2525      new NISuppressor(0, RangeInt.GreaterEqual64.class);
2526  private static NISuppressor arg2_ge_64 =
2527      new NISuppressor(2, RangeInt.GreaterEqual64.class);
2528
2529  private static NISuppressor result_boolean =
2530      new NISuppressor(1, RangeInt.BooleanVal.class);
2531  private static NISuppressor arg1_boolean =
2532      new NISuppressor(0, RangeInt.BooleanVal.class);
2533  private static NISuppressor arg2_boolean =
2534      new NISuppressor(2, RangeInt.BooleanVal.class);
2535
2536  private static NISuppressor result_even =
2537      new NISuppressor(1, RangeInt.Even.class);
2538  private static NISuppressor arg1_even =
2539      new NISuppressor(0, RangeInt.Even.class);
2540  private static NISuppressor arg2_even =
2541      new NISuppressor(2, RangeInt.Even.class);
2542
2543  private static NISuppressor result_power2 =
2544      new NISuppressor(1, RangeInt.PowerOfTwo.class);
2545  private static NISuppressor arg1_power2 =
2546      new NISuppressor(0, RangeInt.PowerOfTwo.class);
2547  private static NISuppressor arg2_power2 =
2548      new NISuppressor(2, RangeInt.PowerOfTwo.class);
2549
2550  private static NISuppressor result_and0_arg1 =
2551      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
2552  private static NISuppressor result_and0_arg2 =
2553      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
2554  private static NISuppressor arg1_and0_arg2 =
2555      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
2556
2557  // The arguments to bitwise subset are backwards from what one
2558  // might expect.  The second argument is a subset of the first
2559  // argument
2560  private static NISuppressor arg1_bw_subset_arg2 =
2561      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
2562  private static NISuppressor arg2_bw_subset_arg1 =
2563      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
2564
2565  private static NISuppressor result_shift0_arg1 =
2566      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
2567  private static NISuppressor result_shift0_arg2 =
2568      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
2569  private static NISuppressor arg1_shift0_arg2 =
2570      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
2571
2572  private static NISuppressor arg2_divides_arg1 =
2573      new NISuppressor(0, 2, NumericInt.Divides.class);
2574  private static NISuppressor arg1_divides_arg2 =
2575      new NISuppressor(2, 0, NumericInt.Divides.class);
2576
2577  private static NISuppressor arg2_valid_shift =
2578      new NISuppressor(2, RangeInt.Bound0_63.class);
2579
2580    private static NISuppressionSet suppressions =
2581      new NISuppressionSet(
2582          new NISuppression[] {
2583
2584            // (r == x) && (z <= x) ==> r = max(x, z)
2585            new NISuppression(result_eq_arg1, arg2_le_arg1, suppressee),
2586
2587            // (r == z) && (x <= z) ==> r = max(x, z)
2588            new NISuppression(result_eq_arg2, arg1_le_arg2, suppressee),
2589
2590          });
2591
2592  // Create a suppression factory for functionBinary
2593
2594}
2595
2596/**
2597 * Represents the invariant {@code z = Maximum(x, y)} over three long
2598 * scalars. 
2599 */
2600public static class MaximumLong_zxy extends FunctionBinary {
2601  // We are Serializable, so we specify a version to allow changes to
2602  // method signatures without breaking serialization.  If you add or
2603  // remove fields, you should change this number to the current date.
2604  static final long serialVersionUID = 20031030L;
2605
2606  private static @Prototype MaximumLong_zxy proto = new @Prototype MaximumLong_zxy ();
2607
2608  /** Returns the prototype invariant for MaximumLong_zxy */
2609  public static @Prototype MaximumLong_zxy get_proto() {
2610    return proto;
2611  }
2612
2613  /** instantiate an invariant on the specified slice */
2614  @Override
2615  protected MaximumLong_zxy instantiate_dyn(@Prototype MaximumLong_zxy this, PptSlice slice) {
2616    return new MaximumLong_zxy (slice);
2617  }
2618
2619  private MaximumLong_zxy (PptSlice slice) {
2620    super(slice);
2621  }
2622
2623  public @Prototype MaximumLong_zxy () {
2624    super();
2625  }
2626
2627  private static String[] method_name = new String[] {"java.lang.Math.max(", ", ", ")"};
2628
2629  @Override
2630  public String[] get_method_name(@GuardSatisfied MaximumLong_zxy this) {
2631    return method_name;
2632  }
2633
2634  private static int function_id = -1;
2635
2636  @Override
2637  public int get_function_id() {
2638    return function_id;
2639  }
2640
2641  @Override
2642  public void set_function_id(int function_id) {
2643    assert MaximumLong_zxy.function_id == -1;
2644    MaximumLong_zxy.function_id = function_id;
2645  }
2646
2647  private static int var_order = 3;
2648
2649  @Override
2650  public int get_var_order(@GuardSatisfied MaximumLong_zxy this) {
2651    return var_order;
2652  }
2653
2654  @Pure
2655  @Override
2656  public boolean is_symmetric() {
2657
2658      return true;
2659  }
2660
2661  @Override
2662
2663  public long func(long x, long y) {
2664
2665    return Math.max(x, y);
2666  }
2667
2668  @Override
2669  public InvariantStatus check_modified(long x, long y,
2670                                      long z, int count) {
2671    return check_ordered(z, x, y, count);
2672  }
2673
2674  @Override
2675  public InvariantStatus add_modified(long x, long y,
2676                                      long z, int count) {
2677    if (Debug.logDetail()) {
2678      log("result=%s, arg1=%s, arg2=%s", z, x, y);
2679    }
2680    return add_ordered(z, x, y, count);
2681  }
2682
2683  @Pure
2684  @Override
2685  public boolean isMaximum() {
2686    return true;
2687  }
2688
2689  /** Returns a list of non-instantiating suppressions for this invariant. */
2690  @Pure
2691  @Override
2692  public @Nullable NISuppressionSet get_ni_suppressions() {
2693    if (NIS.dkconfig_enabled && dkconfig_enabled) {
2694      return suppressions;
2695    } else {
2696      return null;
2697    }
2698  }
2699
2700  /** definition of this invariant (the suppressee) */
2701  private static NISuppressee suppressee = new NISuppressee(MaximumLong_zxy.class, 3);
2702
2703  // suppressor definitions (used below)
2704  private static NISuppressor result_eq_arg1 =
2705      new NISuppressor(2, 0, IntEqual.class);
2706  private static NISuppressor result_eq_arg2 =
2707      new NISuppressor(2, 1, IntEqual.class);
2708  private static NISuppressor arg1_eq_arg2 =
2709      new NISuppressor(0, 1, IntEqual.class);
2710
2711  private static NISuppressor result_lt_arg1 =
2712      new NISuppressor(2, 0, IntLessThan.class);
2713  private static NISuppressor result_lt_arg2 =
2714      new NISuppressor(2, 1, IntLessThan.class);
2715  private static NISuppressor arg1_lt_arg2 =
2716      new NISuppressor(0, 1, IntLessThan.class);
2717  private static NISuppressor arg2_lt_arg1 =
2718      new NISuppressor(1, 0, IntLessThan.class);
2719
2720  private static NISuppressor result_le_arg1 =
2721      new NISuppressor(2, 0, IntLessEqual.class);
2722  private static NISuppressor result_le_arg2 =
2723      new NISuppressor(2, 1, IntLessEqual.class);
2724  private static NISuppressor arg1_le_arg2 =
2725      new NISuppressor(0, 1, IntLessEqual.class);
2726  private static NISuppressor arg2_le_arg1 =
2727      new NISuppressor(1, 0, IntLessEqual.class);
2728
2729  private static NISuppressor result_track0_arg1 =
2730      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
2731  private static NISuppressor result_track0_arg2 =
2732      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
2733  private static NISuppressor arg1_track0_arg2 =
2734      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
2735  private static NISuppressor arg1_track0_result =
2736      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
2737  private static NISuppressor arg2_track0_result =
2738      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
2739  private static NISuppressor arg2_track0_arg1 =
2740      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
2741
2742  private static NISuppressor result_eq_1 =
2743      new NISuppressor(2, RangeInt.EqualOne.class);
2744  private static NISuppressor arg1_eq_1 =
2745      new NISuppressor(0, RangeInt.EqualOne.class);
2746  private static NISuppressor arg2_eq_1 =
2747      new NISuppressor(1, RangeInt.EqualOne.class);
2748
2749  private static NISuppressor result_eq_0 =
2750      new NISuppressor(2, RangeInt.EqualZero.class);
2751  private static NISuppressor arg1_eq_0 =
2752      new NISuppressor(0, RangeInt.EqualZero.class);
2753  private static NISuppressor arg2_eq_0 =
2754      new NISuppressor(1, RangeInt.EqualZero.class);
2755
2756  private static NISuppressor result_ne_0 =
2757      new NISuppressor(2, NonZero.class);
2758  private static NISuppressor arg1_ne_0 =
2759      new NISuppressor(0, NonZero.class);
2760  private static NISuppressor arg2_ne_0 =
2761      new NISuppressor(1, NonZero.class);
2762
2763  private static NISuppressor result_ge_0 =
2764      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
2765  private static NISuppressor arg1_ge_0 =
2766      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
2767  private static NISuppressor arg2_ge_0 =
2768      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
2769
2770  private static NISuppressor result_ge_64 =
2771      new NISuppressor(2, RangeInt.GreaterEqual64.class);
2772  private static NISuppressor arg1_ge_64 =
2773      new NISuppressor(0, RangeInt.GreaterEqual64.class);
2774  private static NISuppressor arg2_ge_64 =
2775      new NISuppressor(1, RangeInt.GreaterEqual64.class);
2776
2777  private static NISuppressor result_boolean =
2778      new NISuppressor(2, RangeInt.BooleanVal.class);
2779  private static NISuppressor arg1_boolean =
2780      new NISuppressor(0, RangeInt.BooleanVal.class);
2781  private static NISuppressor arg2_boolean =
2782      new NISuppressor(1, RangeInt.BooleanVal.class);
2783
2784  private static NISuppressor result_even =
2785      new NISuppressor(2, RangeInt.Even.class);
2786  private static NISuppressor arg1_even =
2787      new NISuppressor(0, RangeInt.Even.class);
2788  private static NISuppressor arg2_even =
2789      new NISuppressor(1, RangeInt.Even.class);
2790
2791  private static NISuppressor result_power2 =
2792      new NISuppressor(2, RangeInt.PowerOfTwo.class);
2793  private static NISuppressor arg1_power2 =
2794      new NISuppressor(0, RangeInt.PowerOfTwo.class);
2795  private static NISuppressor arg2_power2 =
2796      new NISuppressor(1, RangeInt.PowerOfTwo.class);
2797
2798  private static NISuppressor result_and0_arg1 =
2799      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
2800  private static NISuppressor result_and0_arg2 =
2801      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
2802  private static NISuppressor arg1_and0_arg2 =
2803      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
2804
2805  // The arguments to bitwise subset are backwards from what one
2806  // might expect.  The second argument is a subset of the first
2807  // argument
2808  private static NISuppressor arg1_bw_subset_arg2 =
2809      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
2810  private static NISuppressor arg2_bw_subset_arg1 =
2811      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
2812
2813  private static NISuppressor result_shift0_arg1 =
2814      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
2815  private static NISuppressor result_shift0_arg2 =
2816      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
2817  private static NISuppressor arg1_shift0_arg2 =
2818      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
2819
2820  private static NISuppressor arg2_divides_arg1 =
2821      new NISuppressor(0, 1, NumericInt.Divides.class);
2822  private static NISuppressor arg1_divides_arg2 =
2823      new NISuppressor(1, 0, NumericInt.Divides.class);
2824
2825  private static NISuppressor arg2_valid_shift =
2826      new NISuppressor(1, RangeInt.Bound0_63.class);
2827
2828    private static NISuppressionSet suppressions =
2829      new NISuppressionSet(
2830          new NISuppression[] {
2831
2832            // (r == x) && (y <= x) ==> r = max(x, y)
2833            new NISuppression(result_eq_arg1, arg2_le_arg1, suppressee),
2834
2835            // (r == y) && (x <= y) ==> r = max(x, y)
2836            new NISuppression(result_eq_arg2, arg1_le_arg2, suppressee),
2837
2838          });
2839
2840  // Create a suppression factory for functionBinary
2841
2842}
2843
2844  // default is that it is not this function, overriden in the subclass
2845  @Pure
2846  public boolean isDivision() {
2847    return false;
2848  }
2849
2850/**
2851 * Represents the invariant {@code x = Division(y, z)} over three long
2852 * scalars. 
2853 */
2854public static class DivisionLong_xyz extends FunctionBinary {
2855  // We are Serializable, so we specify a version to allow changes to
2856  // method signatures without breaking serialization.  If you add or
2857  // remove fields, you should change this number to the current date.
2858  static final long serialVersionUID = 20031030L;
2859
2860  private static @Prototype DivisionLong_xyz proto = new @Prototype DivisionLong_xyz ();
2861
2862  /** Returns the prototype invariant for DivisionLong_xyz */
2863  public static @Prototype DivisionLong_xyz get_proto() {
2864    return proto;
2865  }
2866
2867  /** instantiate an invariant on the specified slice */
2868  @Override
2869  protected DivisionLong_xyz instantiate_dyn(@Prototype DivisionLong_xyz this, PptSlice slice) {
2870    return new DivisionLong_xyz (slice);
2871  }
2872
2873  private DivisionLong_xyz (PptSlice slice) {
2874    super(slice);
2875  }
2876
2877  public @Prototype DivisionLong_xyz () {
2878    super();
2879  }
2880
2881  private static String[] method_name = new String[] {"", " / ", ""};
2882
2883  @Override
2884  public String[] get_method_name(@GuardSatisfied DivisionLong_xyz this) {
2885    return method_name;
2886  }
2887
2888  private static int function_id = -1;
2889
2890  @Override
2891  public int get_function_id() {
2892    return function_id;
2893  }
2894
2895  @Override
2896  public void set_function_id(int function_id) {
2897    assert DivisionLong_xyz.function_id == -1;
2898    DivisionLong_xyz.function_id = function_id;
2899  }
2900
2901  private static int var_order = 1;
2902
2903  @Override
2904  public int get_var_order(@GuardSatisfied DivisionLong_xyz this) {
2905    return var_order;
2906  }
2907
2908  @Pure
2909  @Override
2910  public boolean is_symmetric() {
2911
2912      return false;
2913  }
2914
2915  @Override
2916
2917  public long func(long y, long z) {
2918
2919    return (y / z);
2920  }
2921
2922  @Override
2923  public InvariantStatus check_modified(long x, long y,
2924                                      long z, int count) {
2925    return check_ordered(x, y, z, count);
2926  }
2927
2928  @Override
2929  public InvariantStatus add_modified(long x, long y,
2930                                      long z, int count) {
2931    if (Debug.logDetail()) {
2932      log("result=%s, arg1=%s, arg2=%s", x, y, z);
2933    }
2934    return add_ordered(x, y, z, count);
2935  }
2936
2937  @Pure
2938  @Override
2939  public boolean isDivision() {
2940    return true;
2941  }
2942
2943  @Pure
2944  @Override
2945  public boolean isExact() {
2946    return true;
2947  }
2948
2949  /** Returns a list of non-instantiating suppressions for this invariant. */
2950  @Pure
2951  @Override
2952  public @Nullable NISuppressionSet get_ni_suppressions() {
2953    if (NIS.dkconfig_enabled && dkconfig_enabled) {
2954      return suppressions;
2955    } else {
2956      return null;
2957    }
2958  }
2959
2960  /** definition of this invariant (the suppressee) */
2961  private static NISuppressee suppressee = new NISuppressee(DivisionLong_xyz.class, 3);
2962
2963  // suppressor definitions (used below)
2964  private static NISuppressor result_eq_arg1 =
2965      new NISuppressor(0, 1, IntEqual.class);
2966  private static NISuppressor result_eq_arg2 =
2967      new NISuppressor(0, 2, IntEqual.class);
2968  private static NISuppressor arg1_eq_arg2 =
2969      new NISuppressor(1, 2, IntEqual.class);
2970
2971  private static NISuppressor result_lt_arg1 =
2972      new NISuppressor(0, 1, IntLessThan.class);
2973  private static NISuppressor result_lt_arg2 =
2974      new NISuppressor(0, 2, IntLessThan.class);
2975  private static NISuppressor arg1_lt_arg2 =
2976      new NISuppressor(1, 2, IntLessThan.class);
2977  private static NISuppressor arg2_lt_arg1 =
2978      new NISuppressor(2, 1, IntLessThan.class);
2979
2980  private static NISuppressor result_le_arg1 =
2981      new NISuppressor(0, 1, IntLessEqual.class);
2982  private static NISuppressor result_le_arg2 =
2983      new NISuppressor(0, 2, IntLessEqual.class);
2984  private static NISuppressor arg1_le_arg2 =
2985      new NISuppressor(1, 2, IntLessEqual.class);
2986  private static NISuppressor arg2_le_arg1 =
2987      new NISuppressor(2, 1, IntLessEqual.class);
2988
2989  private static NISuppressor result_track0_arg1 =
2990      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
2991  private static NISuppressor result_track0_arg2 =
2992      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
2993  private static NISuppressor arg1_track0_arg2 =
2994      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
2995  private static NISuppressor arg1_track0_result =
2996      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
2997  private static NISuppressor arg2_track0_result =
2998      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
2999  private static NISuppressor arg2_track0_arg1 =
3000      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
3001
3002  private static NISuppressor result_eq_1 =
3003      new NISuppressor(0, RangeInt.EqualOne.class);
3004  private static NISuppressor arg1_eq_1 =
3005      new NISuppressor(1, RangeInt.EqualOne.class);
3006  private static NISuppressor arg2_eq_1 =
3007      new NISuppressor(2, RangeInt.EqualOne.class);
3008
3009  private static NISuppressor result_eq_0 =
3010      new NISuppressor(0, RangeInt.EqualZero.class);
3011  private static NISuppressor arg1_eq_0 =
3012      new NISuppressor(1, RangeInt.EqualZero.class);
3013  private static NISuppressor arg2_eq_0 =
3014      new NISuppressor(2, RangeInt.EqualZero.class);
3015
3016  private static NISuppressor result_ne_0 =
3017      new NISuppressor(0, NonZero.class);
3018  private static NISuppressor arg1_ne_0 =
3019      new NISuppressor(1, NonZero.class);
3020  private static NISuppressor arg2_ne_0 =
3021      new NISuppressor(2, NonZero.class);
3022
3023  private static NISuppressor result_ge_0 =
3024      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
3025  private static NISuppressor arg1_ge_0 =
3026      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
3027  private static NISuppressor arg2_ge_0 =
3028      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
3029
3030  private static NISuppressor result_ge_64 =
3031      new NISuppressor(0, RangeInt.GreaterEqual64.class);
3032  private static NISuppressor arg1_ge_64 =
3033      new NISuppressor(1, RangeInt.GreaterEqual64.class);
3034  private static NISuppressor arg2_ge_64 =
3035      new NISuppressor(2, RangeInt.GreaterEqual64.class);
3036
3037  private static NISuppressor result_boolean =
3038      new NISuppressor(0, RangeInt.BooleanVal.class);
3039  private static NISuppressor arg1_boolean =
3040      new NISuppressor(1, RangeInt.BooleanVal.class);
3041  private static NISuppressor arg2_boolean =
3042      new NISuppressor(2, RangeInt.BooleanVal.class);
3043
3044  private static NISuppressor result_even =
3045      new NISuppressor(0, RangeInt.Even.class);
3046  private static NISuppressor arg1_even =
3047      new NISuppressor(1, RangeInt.Even.class);
3048  private static NISuppressor arg2_even =
3049      new NISuppressor(2, RangeInt.Even.class);
3050
3051  private static NISuppressor result_power2 =
3052      new NISuppressor(0, RangeInt.PowerOfTwo.class);
3053  private static NISuppressor arg1_power2 =
3054      new NISuppressor(1, RangeInt.PowerOfTwo.class);
3055  private static NISuppressor arg2_power2 =
3056      new NISuppressor(2, RangeInt.PowerOfTwo.class);
3057
3058  private static NISuppressor result_and0_arg1 =
3059      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
3060  private static NISuppressor result_and0_arg2 =
3061      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
3062  private static NISuppressor arg1_and0_arg2 =
3063      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
3064
3065  // The arguments to bitwise subset are backwards from what one
3066  // might expect.  The second argument is a subset of the first
3067  // argument
3068  private static NISuppressor arg1_bw_subset_arg2 =
3069      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
3070  private static NISuppressor arg2_bw_subset_arg1 =
3071      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
3072
3073  private static NISuppressor result_shift0_arg1 =
3074      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
3075  private static NISuppressor result_shift0_arg2 =
3076      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
3077  private static NISuppressor arg1_shift0_arg2 =
3078      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
3079
3080  private static NISuppressor arg2_divides_arg1 =
3081      new NISuppressor(1, 2, NumericInt.Divides.class);
3082  private static NISuppressor arg1_divides_arg2 =
3083      new NISuppressor(2, 1, NumericInt.Divides.class);
3084
3085  private static NISuppressor arg2_valid_shift =
3086      new NISuppressor(2, RangeInt.Bound0_63.class);
3087
3088    private static NISuppressionSet suppressions =
3089      new NISuppressionSet(
3090          new NISuppression[] {
3091
3092            // (r == 0) && (y < z) && (y >= 0) && (z != 0) ==> r = y / z
3093            new NISuppression(result_eq_0, arg1_lt_arg2, arg1_ge_0, arg2_ne_0, suppressee),
3094
3095            // (y == z) && (z != 0) && (r == 1)
3096            new NISuppression(arg1_eq_arg2, arg2_ne_0, result_eq_1, suppressee),
3097
3098            // (r == y) && (z == 1) ==> r = y / z
3099            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
3100          });
3101
3102  // Create a suppression factory for functionBinary
3103
3104}
3105
3106/**
3107 * Represents the invariant {@code y = Division(x, z)} over three long
3108 * scalars. 
3109 */
3110public static class DivisionLong_yxz extends FunctionBinary {
3111  // We are Serializable, so we specify a version to allow changes to
3112  // method signatures without breaking serialization.  If you add or
3113  // remove fields, you should change this number to the current date.
3114  static final long serialVersionUID = 20031030L;
3115
3116  private static @Prototype DivisionLong_yxz proto = new @Prototype DivisionLong_yxz ();
3117
3118  /** Returns the prototype invariant for DivisionLong_yxz */
3119  public static @Prototype DivisionLong_yxz get_proto() {
3120    return proto;
3121  }
3122
3123  /** instantiate an invariant on the specified slice */
3124  @Override
3125  protected DivisionLong_yxz instantiate_dyn(@Prototype DivisionLong_yxz this, PptSlice slice) {
3126    return new DivisionLong_yxz (slice);
3127  }
3128
3129  private DivisionLong_yxz (PptSlice slice) {
3130    super(slice);
3131  }
3132
3133  public @Prototype DivisionLong_yxz () {
3134    super();
3135  }
3136
3137  private static String[] method_name = new String[] {"", " / ", ""};
3138
3139  @Override
3140  public String[] get_method_name(@GuardSatisfied DivisionLong_yxz this) {
3141    return method_name;
3142  }
3143
3144  private static int function_id = -1;
3145
3146  @Override
3147  public int get_function_id() {
3148    return function_id;
3149  }
3150
3151  @Override
3152  public void set_function_id(int function_id) {
3153    assert DivisionLong_yxz.function_id == -1;
3154    DivisionLong_yxz.function_id = function_id;
3155  }
3156
3157  private static int var_order = 2;
3158
3159  @Override
3160  public int get_var_order(@GuardSatisfied DivisionLong_yxz this) {
3161    return var_order;
3162  }
3163
3164  @Pure
3165  @Override
3166  public boolean is_symmetric() {
3167
3168      return false;
3169  }
3170
3171  @Override
3172
3173  public long func(long x, long z) {
3174
3175    return (x / z);
3176  }
3177
3178  @Override
3179  public InvariantStatus check_modified(long x, long y,
3180                                      long z, int count) {
3181    return check_ordered(y, x, z, count);
3182  }
3183
3184  @Override
3185  public InvariantStatus add_modified(long x, long y,
3186                                      long z, int count) {
3187    if (Debug.logDetail()) {
3188      log("result=%s, arg1=%s, arg2=%s", y, x, z);
3189    }
3190    return add_ordered(y, x, z, count);
3191  }
3192
3193  @Pure
3194  @Override
3195  public boolean isDivision() {
3196    return true;
3197  }
3198
3199  @Pure
3200  @Override
3201  public boolean isExact() {
3202    return true;
3203  }
3204
3205  /** Returns a list of non-instantiating suppressions for this invariant. */
3206  @Pure
3207  @Override
3208  public @Nullable NISuppressionSet get_ni_suppressions() {
3209    if (NIS.dkconfig_enabled && dkconfig_enabled) {
3210      return suppressions;
3211    } else {
3212      return null;
3213    }
3214  }
3215
3216  /** definition of this invariant (the suppressee) */
3217  private static NISuppressee suppressee = new NISuppressee(DivisionLong_yxz.class, 3);
3218
3219  // suppressor definitions (used below)
3220  private static NISuppressor result_eq_arg1 =
3221      new NISuppressor(1, 0, IntEqual.class);
3222  private static NISuppressor result_eq_arg2 =
3223      new NISuppressor(1, 2, IntEqual.class);
3224  private static NISuppressor arg1_eq_arg2 =
3225      new NISuppressor(0, 2, IntEqual.class);
3226
3227  private static NISuppressor result_lt_arg1 =
3228      new NISuppressor(1, 0, IntLessThan.class);
3229  private static NISuppressor result_lt_arg2 =
3230      new NISuppressor(1, 2, IntLessThan.class);
3231  private static NISuppressor arg1_lt_arg2 =
3232      new NISuppressor(0, 2, IntLessThan.class);
3233  private static NISuppressor arg2_lt_arg1 =
3234      new NISuppressor(2, 0, IntLessThan.class);
3235
3236  private static NISuppressor result_le_arg1 =
3237      new NISuppressor(1, 0, IntLessEqual.class);
3238  private static NISuppressor result_le_arg2 =
3239      new NISuppressor(1, 2, IntLessEqual.class);
3240  private static NISuppressor arg1_le_arg2 =
3241      new NISuppressor(0, 2, IntLessEqual.class);
3242  private static NISuppressor arg2_le_arg1 =
3243      new NISuppressor(2, 0, IntLessEqual.class);
3244
3245  private static NISuppressor result_track0_arg1 =
3246      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
3247  private static NISuppressor result_track0_arg2 =
3248      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
3249  private static NISuppressor arg1_track0_arg2 =
3250      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
3251  private static NISuppressor arg1_track0_result =
3252      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
3253  private static NISuppressor arg2_track0_result =
3254      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
3255  private static NISuppressor arg2_track0_arg1 =
3256      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
3257
3258  private static NISuppressor result_eq_1 =
3259      new NISuppressor(1, RangeInt.EqualOne.class);
3260  private static NISuppressor arg1_eq_1 =
3261      new NISuppressor(0, RangeInt.EqualOne.class);
3262  private static NISuppressor arg2_eq_1 =
3263      new NISuppressor(2, RangeInt.EqualOne.class);
3264
3265  private static NISuppressor result_eq_0 =
3266      new NISuppressor(1, RangeInt.EqualZero.class);
3267  private static NISuppressor arg1_eq_0 =
3268      new NISuppressor(0, RangeInt.EqualZero.class);
3269  private static NISuppressor arg2_eq_0 =
3270      new NISuppressor(2, RangeInt.EqualZero.class);
3271
3272  private static NISuppressor result_ne_0 =
3273      new NISuppressor(1, NonZero.class);
3274  private static NISuppressor arg1_ne_0 =
3275      new NISuppressor(0, NonZero.class);
3276  private static NISuppressor arg2_ne_0 =
3277      new NISuppressor(2, NonZero.class);
3278
3279  private static NISuppressor result_ge_0 =
3280      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
3281  private static NISuppressor arg1_ge_0 =
3282      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
3283  private static NISuppressor arg2_ge_0 =
3284      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
3285
3286  private static NISuppressor result_ge_64 =
3287      new NISuppressor(1, RangeInt.GreaterEqual64.class);
3288  private static NISuppressor arg1_ge_64 =
3289      new NISuppressor(0, RangeInt.GreaterEqual64.class);
3290  private static NISuppressor arg2_ge_64 =
3291      new NISuppressor(2, RangeInt.GreaterEqual64.class);
3292
3293  private static NISuppressor result_boolean =
3294      new NISuppressor(1, RangeInt.BooleanVal.class);
3295  private static NISuppressor arg1_boolean =
3296      new NISuppressor(0, RangeInt.BooleanVal.class);
3297  private static NISuppressor arg2_boolean =
3298      new NISuppressor(2, RangeInt.BooleanVal.class);
3299
3300  private static NISuppressor result_even =
3301      new NISuppressor(1, RangeInt.Even.class);
3302  private static NISuppressor arg1_even =
3303      new NISuppressor(0, RangeInt.Even.class);
3304  private static NISuppressor arg2_even =
3305      new NISuppressor(2, RangeInt.Even.class);
3306
3307  private static NISuppressor result_power2 =
3308      new NISuppressor(1, RangeInt.PowerOfTwo.class);
3309  private static NISuppressor arg1_power2 =
3310      new NISuppressor(0, RangeInt.PowerOfTwo.class);
3311  private static NISuppressor arg2_power2 =
3312      new NISuppressor(2, RangeInt.PowerOfTwo.class);
3313
3314  private static NISuppressor result_and0_arg1 =
3315      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
3316  private static NISuppressor result_and0_arg2 =
3317      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
3318  private static NISuppressor arg1_and0_arg2 =
3319      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
3320
3321  // The arguments to bitwise subset are backwards from what one
3322  // might expect.  The second argument is a subset of the first
3323  // argument
3324  private static NISuppressor arg1_bw_subset_arg2 =
3325      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
3326  private static NISuppressor arg2_bw_subset_arg1 =
3327      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
3328
3329  private static NISuppressor result_shift0_arg1 =
3330      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
3331  private static NISuppressor result_shift0_arg2 =
3332      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
3333  private static NISuppressor arg1_shift0_arg2 =
3334      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
3335
3336  private static NISuppressor arg2_divides_arg1 =
3337      new NISuppressor(0, 2, NumericInt.Divides.class);
3338  private static NISuppressor arg1_divides_arg2 =
3339      new NISuppressor(2, 0, NumericInt.Divides.class);
3340
3341  private static NISuppressor arg2_valid_shift =
3342      new NISuppressor(2, RangeInt.Bound0_63.class);
3343
3344    private static NISuppressionSet suppressions =
3345      new NISuppressionSet(
3346          new NISuppression[] {
3347
3348            // (r == 0) && (x < z) && (x >= 0) && (z != 0) ==> r = x / z
3349            new NISuppression(result_eq_0, arg1_lt_arg2, arg1_ge_0, arg2_ne_0, suppressee),
3350
3351            // (x == z) && (z != 0) && (r == 1)
3352            new NISuppression(arg1_eq_arg2, arg2_ne_0, result_eq_1, suppressee),
3353
3354            // (r == x) && (z == 1) ==> r = x / z
3355            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
3356          });
3357
3358  // Create a suppression factory for functionBinary
3359
3360}
3361
3362/**
3363 * Represents the invariant {@code z = Division(x, y)} over three long
3364 * scalars. 
3365 */
3366public static class DivisionLong_zxy extends FunctionBinary {
3367  // We are Serializable, so we specify a version to allow changes to
3368  // method signatures without breaking serialization.  If you add or
3369  // remove fields, you should change this number to the current date.
3370  static final long serialVersionUID = 20031030L;
3371
3372  private static @Prototype DivisionLong_zxy proto = new @Prototype DivisionLong_zxy ();
3373
3374  /** Returns the prototype invariant for DivisionLong_zxy */
3375  public static @Prototype DivisionLong_zxy get_proto() {
3376    return proto;
3377  }
3378
3379  /** instantiate an invariant on the specified slice */
3380  @Override
3381  protected DivisionLong_zxy instantiate_dyn(@Prototype DivisionLong_zxy this, PptSlice slice) {
3382    return new DivisionLong_zxy (slice);
3383  }
3384
3385  private DivisionLong_zxy (PptSlice slice) {
3386    super(slice);
3387  }
3388
3389  public @Prototype DivisionLong_zxy () {
3390    super();
3391  }
3392
3393  private static String[] method_name = new String[] {"", " / ", ""};
3394
3395  @Override
3396  public String[] get_method_name(@GuardSatisfied DivisionLong_zxy this) {
3397    return method_name;
3398  }
3399
3400  private static int function_id = -1;
3401
3402  @Override
3403  public int get_function_id() {
3404    return function_id;
3405  }
3406
3407  @Override
3408  public void set_function_id(int function_id) {
3409    assert DivisionLong_zxy.function_id == -1;
3410    DivisionLong_zxy.function_id = function_id;
3411  }
3412
3413  private static int var_order = 3;
3414
3415  @Override
3416  public int get_var_order(@GuardSatisfied DivisionLong_zxy this) {
3417    return var_order;
3418  }
3419
3420  @Pure
3421  @Override
3422  public boolean is_symmetric() {
3423
3424      return false;
3425  }
3426
3427  @Override
3428
3429  public long func(long x, long y) {
3430
3431    return (x / y);
3432  }
3433
3434  @Override
3435  public InvariantStatus check_modified(long x, long y,
3436                                      long z, int count) {
3437    return check_ordered(z, x, y, count);
3438  }
3439
3440  @Override
3441  public InvariantStatus add_modified(long x, long y,
3442                                      long z, int count) {
3443    if (Debug.logDetail()) {
3444      log("result=%s, arg1=%s, arg2=%s", z, x, y);
3445    }
3446    return add_ordered(z, x, y, count);
3447  }
3448
3449  @Pure
3450  @Override
3451  public boolean isDivision() {
3452    return true;
3453  }
3454
3455  @Pure
3456  @Override
3457  public boolean isExact() {
3458    return true;
3459  }
3460
3461  /** Returns a list of non-instantiating suppressions for this invariant. */
3462  @Pure
3463  @Override
3464  public @Nullable NISuppressionSet get_ni_suppressions() {
3465    if (NIS.dkconfig_enabled && dkconfig_enabled) {
3466      return suppressions;
3467    } else {
3468      return null;
3469    }
3470  }
3471
3472  /** definition of this invariant (the suppressee) */
3473  private static NISuppressee suppressee = new NISuppressee(DivisionLong_zxy.class, 3);
3474
3475  // suppressor definitions (used below)
3476  private static NISuppressor result_eq_arg1 =
3477      new NISuppressor(2, 0, IntEqual.class);
3478  private static NISuppressor result_eq_arg2 =
3479      new NISuppressor(2, 1, IntEqual.class);
3480  private static NISuppressor arg1_eq_arg2 =
3481      new NISuppressor(0, 1, IntEqual.class);
3482
3483  private static NISuppressor result_lt_arg1 =
3484      new NISuppressor(2, 0, IntLessThan.class);
3485  private static NISuppressor result_lt_arg2 =
3486      new NISuppressor(2, 1, IntLessThan.class);
3487  private static NISuppressor arg1_lt_arg2 =
3488      new NISuppressor(0, 1, IntLessThan.class);
3489  private static NISuppressor arg2_lt_arg1 =
3490      new NISuppressor(1, 0, IntLessThan.class);
3491
3492  private static NISuppressor result_le_arg1 =
3493      new NISuppressor(2, 0, IntLessEqual.class);
3494  private static NISuppressor result_le_arg2 =
3495      new NISuppressor(2, 1, IntLessEqual.class);
3496  private static NISuppressor arg1_le_arg2 =
3497      new NISuppressor(0, 1, IntLessEqual.class);
3498  private static NISuppressor arg2_le_arg1 =
3499      new NISuppressor(1, 0, IntLessEqual.class);
3500
3501  private static NISuppressor result_track0_arg1 =
3502      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
3503  private static NISuppressor result_track0_arg2 =
3504      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
3505  private static NISuppressor arg1_track0_arg2 =
3506      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
3507  private static NISuppressor arg1_track0_result =
3508      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
3509  private static NISuppressor arg2_track0_result =
3510      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
3511  private static NISuppressor arg2_track0_arg1 =
3512      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
3513
3514  private static NISuppressor result_eq_1 =
3515      new NISuppressor(2, RangeInt.EqualOne.class);
3516  private static NISuppressor arg1_eq_1 =
3517      new NISuppressor(0, RangeInt.EqualOne.class);
3518  private static NISuppressor arg2_eq_1 =
3519      new NISuppressor(1, RangeInt.EqualOne.class);
3520
3521  private static NISuppressor result_eq_0 =
3522      new NISuppressor(2, RangeInt.EqualZero.class);
3523  private static NISuppressor arg1_eq_0 =
3524      new NISuppressor(0, RangeInt.EqualZero.class);
3525  private static NISuppressor arg2_eq_0 =
3526      new NISuppressor(1, RangeInt.EqualZero.class);
3527
3528  private static NISuppressor result_ne_0 =
3529      new NISuppressor(2, NonZero.class);
3530  private static NISuppressor arg1_ne_0 =
3531      new NISuppressor(0, NonZero.class);
3532  private static NISuppressor arg2_ne_0 =
3533      new NISuppressor(1, NonZero.class);
3534
3535  private static NISuppressor result_ge_0 =
3536      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
3537  private static NISuppressor arg1_ge_0 =
3538      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
3539  private static NISuppressor arg2_ge_0 =
3540      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
3541
3542  private static NISuppressor result_ge_64 =
3543      new NISuppressor(2, RangeInt.GreaterEqual64.class);
3544  private static NISuppressor arg1_ge_64 =
3545      new NISuppressor(0, RangeInt.GreaterEqual64.class);
3546  private static NISuppressor arg2_ge_64 =
3547      new NISuppressor(1, RangeInt.GreaterEqual64.class);
3548
3549  private static NISuppressor result_boolean =
3550      new NISuppressor(2, RangeInt.BooleanVal.class);
3551  private static NISuppressor arg1_boolean =
3552      new NISuppressor(0, RangeInt.BooleanVal.class);
3553  private static NISuppressor arg2_boolean =
3554      new NISuppressor(1, RangeInt.BooleanVal.class);
3555
3556  private static NISuppressor result_even =
3557      new NISuppressor(2, RangeInt.Even.class);
3558  private static NISuppressor arg1_even =
3559      new NISuppressor(0, RangeInt.Even.class);
3560  private static NISuppressor arg2_even =
3561      new NISuppressor(1, RangeInt.Even.class);
3562
3563  private static NISuppressor result_power2 =
3564      new NISuppressor(2, RangeInt.PowerOfTwo.class);
3565  private static NISuppressor arg1_power2 =
3566      new NISuppressor(0, RangeInt.PowerOfTwo.class);
3567  private static NISuppressor arg2_power2 =
3568      new NISuppressor(1, RangeInt.PowerOfTwo.class);
3569
3570  private static NISuppressor result_and0_arg1 =
3571      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
3572  private static NISuppressor result_and0_arg2 =
3573      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
3574  private static NISuppressor arg1_and0_arg2 =
3575      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
3576
3577  // The arguments to bitwise subset are backwards from what one
3578  // might expect.  The second argument is a subset of the first
3579  // argument
3580  private static NISuppressor arg1_bw_subset_arg2 =
3581      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
3582  private static NISuppressor arg2_bw_subset_arg1 =
3583      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
3584
3585  private static NISuppressor result_shift0_arg1 =
3586      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
3587  private static NISuppressor result_shift0_arg2 =
3588      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
3589  private static NISuppressor arg1_shift0_arg2 =
3590      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
3591
3592  private static NISuppressor arg2_divides_arg1 =
3593      new NISuppressor(0, 1, NumericInt.Divides.class);
3594  private static NISuppressor arg1_divides_arg2 =
3595      new NISuppressor(1, 0, NumericInt.Divides.class);
3596
3597  private static NISuppressor arg2_valid_shift =
3598      new NISuppressor(1, RangeInt.Bound0_63.class);
3599
3600    private static NISuppressionSet suppressions =
3601      new NISuppressionSet(
3602          new NISuppression[] {
3603
3604            // (r == 0) && (x < y) && (x >= 0) && (y != 0) ==> r = x / y
3605            new NISuppression(result_eq_0, arg1_lt_arg2, arg1_ge_0, arg2_ne_0, suppressee),
3606
3607            // (x == y) && (y != 0) && (r == 1)
3608            new NISuppression(arg1_eq_arg2, arg2_ne_0, result_eq_1, suppressee),
3609
3610            // (r == x) && (y == 1) ==> r = x / y
3611            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
3612          });
3613
3614  // Create a suppression factory for functionBinary
3615
3616}
3617
3618/**
3619 * Represents the invariant {@code x = Division(z, y)} over three long
3620 * scalars. 
3621 */
3622public static class DivisionLong_xzy extends FunctionBinary {
3623  // We are Serializable, so we specify a version to allow changes to
3624  // method signatures without breaking serialization.  If you add or
3625  // remove fields, you should change this number to the current date.
3626  static final long serialVersionUID = 20031030L;
3627
3628  private static @Prototype DivisionLong_xzy proto = new @Prototype DivisionLong_xzy ();
3629
3630  /** Returns the prototype invariant for DivisionLong_xzy */
3631  public static @Prototype DivisionLong_xzy get_proto() {
3632    return proto;
3633  }
3634
3635  /** instantiate an invariant on the specified slice */
3636  @Override
3637  protected DivisionLong_xzy instantiate_dyn(@Prototype DivisionLong_xzy this, PptSlice slice) {
3638    return new DivisionLong_xzy (slice);
3639  }
3640
3641  private DivisionLong_xzy (PptSlice slice) {
3642    super(slice);
3643  }
3644
3645  public @Prototype DivisionLong_xzy () {
3646    super();
3647  }
3648
3649  private static String[] method_name = new String[] {"", " / ", ""};
3650
3651  @Override
3652  public String[] get_method_name(@GuardSatisfied DivisionLong_xzy this) {
3653    return method_name;
3654  }
3655
3656  private static int function_id = -1;
3657
3658  @Override
3659  public int get_function_id() {
3660    return function_id;
3661  }
3662
3663  @Override
3664  public void set_function_id(int function_id) {
3665    assert DivisionLong_xzy.function_id == -1;
3666    DivisionLong_xzy.function_id = function_id;
3667  }
3668
3669  private static int var_order = 4;
3670
3671  @Override
3672  public int get_var_order(@GuardSatisfied DivisionLong_xzy this) {
3673    return var_order;
3674  }
3675
3676  @Pure
3677  @Override
3678  public boolean is_symmetric() {
3679
3680      return false;
3681  }
3682
3683  @Override
3684
3685  public long func(long z, long y) {
3686
3687    return (z / y);
3688  }
3689
3690  @Override
3691  public InvariantStatus check_modified(long x, long y,
3692                                      long z, int count) {
3693    return check_ordered(x, z, y, count);
3694  }
3695
3696  @Override
3697  public InvariantStatus add_modified(long x, long y,
3698                                      long z, int count) {
3699    if (Debug.logDetail()) {
3700      log("result=%s, arg1=%s, arg2=%s", x, z, y);
3701    }
3702    return add_ordered(x, z, y, count);
3703  }
3704
3705  @Pure
3706  @Override
3707  public boolean isDivision() {
3708    return true;
3709  }
3710
3711  @Pure
3712  @Override
3713  public boolean isExact() {
3714    return true;
3715  }
3716
3717  /** Returns a list of non-instantiating suppressions for this invariant. */
3718  @Pure
3719  @Override
3720  public @Nullable NISuppressionSet get_ni_suppressions() {
3721    if (NIS.dkconfig_enabled && dkconfig_enabled) {
3722      return suppressions;
3723    } else {
3724      return null;
3725    }
3726  }
3727
3728  /** definition of this invariant (the suppressee) */
3729  private static NISuppressee suppressee = new NISuppressee(DivisionLong_xzy.class, 3);
3730
3731  // suppressor definitions (used below)
3732  private static NISuppressor result_eq_arg1 =
3733      new NISuppressor(0, 2, IntEqual.class);
3734  private static NISuppressor result_eq_arg2 =
3735      new NISuppressor(0, 1, IntEqual.class);
3736  private static NISuppressor arg1_eq_arg2 =
3737      new NISuppressor(2, 1, IntEqual.class);
3738
3739  private static NISuppressor result_lt_arg1 =
3740      new NISuppressor(0, 2, IntLessThan.class);
3741  private static NISuppressor result_lt_arg2 =
3742      new NISuppressor(0, 1, IntLessThan.class);
3743  private static NISuppressor arg1_lt_arg2 =
3744      new NISuppressor(2, 1, IntLessThan.class);
3745  private static NISuppressor arg2_lt_arg1 =
3746      new NISuppressor(1, 2, IntLessThan.class);
3747
3748  private static NISuppressor result_le_arg1 =
3749      new NISuppressor(0, 2, IntLessEqual.class);
3750  private static NISuppressor result_le_arg2 =
3751      new NISuppressor(0, 1, IntLessEqual.class);
3752  private static NISuppressor arg1_le_arg2 =
3753      new NISuppressor(2, 1, IntLessEqual.class);
3754  private static NISuppressor arg2_le_arg1 =
3755      new NISuppressor(1, 2, IntLessEqual.class);
3756
3757  private static NISuppressor result_track0_arg1 =
3758      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
3759  private static NISuppressor result_track0_arg2 =
3760      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
3761  private static NISuppressor arg1_track0_arg2 =
3762      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
3763  private static NISuppressor arg1_track0_result =
3764      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
3765  private static NISuppressor arg2_track0_result =
3766      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
3767  private static NISuppressor arg2_track0_arg1 =
3768      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
3769
3770  private static NISuppressor result_eq_1 =
3771      new NISuppressor(0, RangeInt.EqualOne.class);
3772  private static NISuppressor arg1_eq_1 =
3773      new NISuppressor(2, RangeInt.EqualOne.class);
3774  private static NISuppressor arg2_eq_1 =
3775      new NISuppressor(1, RangeInt.EqualOne.class);
3776
3777  private static NISuppressor result_eq_0 =
3778      new NISuppressor(0, RangeInt.EqualZero.class);
3779  private static NISuppressor arg1_eq_0 =
3780      new NISuppressor(2, RangeInt.EqualZero.class);
3781  private static NISuppressor arg2_eq_0 =
3782      new NISuppressor(1, RangeInt.EqualZero.class);
3783
3784  private static NISuppressor result_ne_0 =
3785      new NISuppressor(0, NonZero.class);
3786  private static NISuppressor arg1_ne_0 =
3787      new NISuppressor(2, NonZero.class);
3788  private static NISuppressor arg2_ne_0 =
3789      new NISuppressor(1, NonZero.class);
3790
3791  private static NISuppressor result_ge_0 =
3792      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
3793  private static NISuppressor arg1_ge_0 =
3794      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
3795  private static NISuppressor arg2_ge_0 =
3796      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
3797
3798  private static NISuppressor result_ge_64 =
3799      new NISuppressor(0, RangeInt.GreaterEqual64.class);
3800  private static NISuppressor arg1_ge_64 =
3801      new NISuppressor(2, RangeInt.GreaterEqual64.class);
3802  private static NISuppressor arg2_ge_64 =
3803      new NISuppressor(1, RangeInt.GreaterEqual64.class);
3804
3805  private static NISuppressor result_boolean =
3806      new NISuppressor(0, RangeInt.BooleanVal.class);
3807  private static NISuppressor arg1_boolean =
3808      new NISuppressor(2, RangeInt.BooleanVal.class);
3809  private static NISuppressor arg2_boolean =
3810      new NISuppressor(1, RangeInt.BooleanVal.class);
3811
3812  private static NISuppressor result_even =
3813      new NISuppressor(0, RangeInt.Even.class);
3814  private static NISuppressor arg1_even =
3815      new NISuppressor(2, RangeInt.Even.class);
3816  private static NISuppressor arg2_even =
3817      new NISuppressor(1, RangeInt.Even.class);
3818
3819  private static NISuppressor result_power2 =
3820      new NISuppressor(0, RangeInt.PowerOfTwo.class);
3821  private static NISuppressor arg1_power2 =
3822      new NISuppressor(2, RangeInt.PowerOfTwo.class);
3823  private static NISuppressor arg2_power2 =
3824      new NISuppressor(1, RangeInt.PowerOfTwo.class);
3825
3826  private static NISuppressor result_and0_arg1 =
3827      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
3828  private static NISuppressor result_and0_arg2 =
3829      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
3830  private static NISuppressor arg1_and0_arg2 =
3831      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
3832
3833  // The arguments to bitwise subset are backwards from what one
3834  // might expect.  The second argument is a subset of the first
3835  // argument
3836  private static NISuppressor arg1_bw_subset_arg2 =
3837      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
3838  private static NISuppressor arg2_bw_subset_arg1 =
3839      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
3840
3841  private static NISuppressor result_shift0_arg1 =
3842      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
3843  private static NISuppressor result_shift0_arg2 =
3844      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
3845  private static NISuppressor arg1_shift0_arg2 =
3846      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
3847
3848  private static NISuppressor arg2_divides_arg1 =
3849      new NISuppressor(2, 1, NumericInt.Divides.class);
3850  private static NISuppressor arg1_divides_arg2 =
3851      new NISuppressor(1, 2, NumericInt.Divides.class);
3852
3853  private static NISuppressor arg2_valid_shift =
3854      new NISuppressor(1, RangeInt.Bound0_63.class);
3855
3856    private static NISuppressionSet suppressions =
3857      new NISuppressionSet(
3858          new NISuppression[] {
3859
3860            // (r == 0) && (z < y) && (z >= 0) && (y != 0) ==> r = z / y
3861            new NISuppression(result_eq_0, arg1_lt_arg2, arg1_ge_0, arg2_ne_0, suppressee),
3862
3863            // (z == y) && (y != 0) && (r == 1)
3864            new NISuppression(arg1_eq_arg2, arg2_ne_0, result_eq_1, suppressee),
3865
3866            // (r == z) && (y == 1) ==> r = z / y
3867            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
3868          });
3869
3870  // Create a suppression factory for functionBinary
3871
3872}
3873
3874/**
3875 * Represents the invariant {@code y = Division(z, x)} over three long
3876 * scalars. 
3877 */
3878public static class DivisionLong_yzx extends FunctionBinary {
3879  // We are Serializable, so we specify a version to allow changes to
3880  // method signatures without breaking serialization.  If you add or
3881  // remove fields, you should change this number to the current date.
3882  static final long serialVersionUID = 20031030L;
3883
3884  private static @Prototype DivisionLong_yzx proto = new @Prototype DivisionLong_yzx ();
3885
3886  /** Returns the prototype invariant for DivisionLong_yzx */
3887  public static @Prototype DivisionLong_yzx get_proto() {
3888    return proto;
3889  }
3890
3891  /** instantiate an invariant on the specified slice */
3892  @Override
3893  protected DivisionLong_yzx instantiate_dyn(@Prototype DivisionLong_yzx this, PptSlice slice) {
3894    return new DivisionLong_yzx (slice);
3895  }
3896
3897  private DivisionLong_yzx (PptSlice slice) {
3898    super(slice);
3899  }
3900
3901  public @Prototype DivisionLong_yzx () {
3902    super();
3903  }
3904
3905  private static String[] method_name = new String[] {"", " / ", ""};
3906
3907  @Override
3908  public String[] get_method_name(@GuardSatisfied DivisionLong_yzx this) {
3909    return method_name;
3910  }
3911
3912  private static int function_id = -1;
3913
3914  @Override
3915  public int get_function_id() {
3916    return function_id;
3917  }
3918
3919  @Override
3920  public void set_function_id(int function_id) {
3921    assert DivisionLong_yzx.function_id == -1;
3922    DivisionLong_yzx.function_id = function_id;
3923  }
3924
3925  private static int var_order = 5;
3926
3927  @Override
3928  public int get_var_order(@GuardSatisfied DivisionLong_yzx this) {
3929    return var_order;
3930  }
3931
3932  @Pure
3933  @Override
3934  public boolean is_symmetric() {
3935
3936      return false;
3937  }
3938
3939  @Override
3940
3941  public long func(long z, long x) {
3942
3943    return (z / x);
3944  }
3945
3946  @Override
3947  public InvariantStatus check_modified(long x, long y,
3948                                      long z, int count) {
3949    return check_ordered(y, z, x, count);
3950  }
3951
3952  @Override
3953  public InvariantStatus add_modified(long x, long y,
3954                                      long z, int count) {
3955    if (Debug.logDetail()) {
3956      log("result=%s, arg1=%s, arg2=%s", y, z, x);
3957    }
3958    return add_ordered(y, z, x, count);
3959  }
3960
3961  @Pure
3962  @Override
3963  public boolean isDivision() {
3964    return true;
3965  }
3966
3967  @Pure
3968  @Override
3969  public boolean isExact() {
3970    return true;
3971  }
3972
3973  /** Returns a list of non-instantiating suppressions for this invariant. */
3974  @Pure
3975  @Override
3976  public @Nullable NISuppressionSet get_ni_suppressions() {
3977    if (NIS.dkconfig_enabled && dkconfig_enabled) {
3978      return suppressions;
3979    } else {
3980      return null;
3981    }
3982  }
3983
3984  /** definition of this invariant (the suppressee) */
3985  private static NISuppressee suppressee = new NISuppressee(DivisionLong_yzx.class, 3);
3986
3987  // suppressor definitions (used below)
3988  private static NISuppressor result_eq_arg1 =
3989      new NISuppressor(1, 2, IntEqual.class);
3990  private static NISuppressor result_eq_arg2 =
3991      new NISuppressor(1, 0, IntEqual.class);
3992  private static NISuppressor arg1_eq_arg2 =
3993      new NISuppressor(2, 0, IntEqual.class);
3994
3995  private static NISuppressor result_lt_arg1 =
3996      new NISuppressor(1, 2, IntLessThan.class);
3997  private static NISuppressor result_lt_arg2 =
3998      new NISuppressor(1, 0, IntLessThan.class);
3999  private static NISuppressor arg1_lt_arg2 =
4000      new NISuppressor(2, 0, IntLessThan.class);
4001  private static NISuppressor arg2_lt_arg1 =
4002      new NISuppressor(0, 2, IntLessThan.class);
4003
4004  private static NISuppressor result_le_arg1 =
4005      new NISuppressor(1, 2, IntLessEqual.class);
4006  private static NISuppressor result_le_arg2 =
4007      new NISuppressor(1, 0, IntLessEqual.class);
4008  private static NISuppressor arg1_le_arg2 =
4009      new NISuppressor(2, 0, IntLessEqual.class);
4010  private static NISuppressor arg2_le_arg1 =
4011      new NISuppressor(0, 2, IntLessEqual.class);
4012
4013  private static NISuppressor result_track0_arg1 =
4014      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
4015  private static NISuppressor result_track0_arg2 =
4016      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
4017  private static NISuppressor arg1_track0_arg2 =
4018      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
4019  private static NISuppressor arg1_track0_result =
4020      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
4021  private static NISuppressor arg2_track0_result =
4022      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
4023  private static NISuppressor arg2_track0_arg1 =
4024      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
4025
4026  private static NISuppressor result_eq_1 =
4027      new NISuppressor(1, RangeInt.EqualOne.class);
4028  private static NISuppressor arg1_eq_1 =
4029      new NISuppressor(2, RangeInt.EqualOne.class);
4030  private static NISuppressor arg2_eq_1 =
4031      new NISuppressor(0, RangeInt.EqualOne.class);
4032
4033  private static NISuppressor result_eq_0 =
4034      new NISuppressor(1, RangeInt.EqualZero.class);
4035  private static NISuppressor arg1_eq_0 =
4036      new NISuppressor(2, RangeInt.EqualZero.class);
4037  private static NISuppressor arg2_eq_0 =
4038      new NISuppressor(0, RangeInt.EqualZero.class);
4039
4040  private static NISuppressor result_ne_0 =
4041      new NISuppressor(1, NonZero.class);
4042  private static NISuppressor arg1_ne_0 =
4043      new NISuppressor(2, NonZero.class);
4044  private static NISuppressor arg2_ne_0 =
4045      new NISuppressor(0, NonZero.class);
4046
4047  private static NISuppressor result_ge_0 =
4048      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
4049  private static NISuppressor arg1_ge_0 =
4050      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
4051  private static NISuppressor arg2_ge_0 =
4052      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
4053
4054  private static NISuppressor result_ge_64 =
4055      new NISuppressor(1, RangeInt.GreaterEqual64.class);
4056  private static NISuppressor arg1_ge_64 =
4057      new NISuppressor(2, RangeInt.GreaterEqual64.class);
4058  private static NISuppressor arg2_ge_64 =
4059      new NISuppressor(0, RangeInt.GreaterEqual64.class);
4060
4061  private static NISuppressor result_boolean =
4062      new NISuppressor(1, RangeInt.BooleanVal.class);
4063  private static NISuppressor arg1_boolean =
4064      new NISuppressor(2, RangeInt.BooleanVal.class);
4065  private static NISuppressor arg2_boolean =
4066      new NISuppressor(0, RangeInt.BooleanVal.class);
4067
4068  private static NISuppressor result_even =
4069      new NISuppressor(1, RangeInt.Even.class);
4070  private static NISuppressor arg1_even =
4071      new NISuppressor(2, RangeInt.Even.class);
4072  private static NISuppressor arg2_even =
4073      new NISuppressor(0, RangeInt.Even.class);
4074
4075  private static NISuppressor result_power2 =
4076      new NISuppressor(1, RangeInt.PowerOfTwo.class);
4077  private static NISuppressor arg1_power2 =
4078      new NISuppressor(2, RangeInt.PowerOfTwo.class);
4079  private static NISuppressor arg2_power2 =
4080      new NISuppressor(0, RangeInt.PowerOfTwo.class);
4081
4082  private static NISuppressor result_and0_arg1 =
4083      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
4084  private static NISuppressor result_and0_arg2 =
4085      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
4086  private static NISuppressor arg1_and0_arg2 =
4087      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
4088
4089  // The arguments to bitwise subset are backwards from what one
4090  // might expect.  The second argument is a subset of the first
4091  // argument
4092  private static NISuppressor arg1_bw_subset_arg2 =
4093      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
4094  private static NISuppressor arg2_bw_subset_arg1 =
4095      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
4096
4097  private static NISuppressor result_shift0_arg1 =
4098      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
4099  private static NISuppressor result_shift0_arg2 =
4100      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
4101  private static NISuppressor arg1_shift0_arg2 =
4102      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
4103
4104  private static NISuppressor arg2_divides_arg1 =
4105      new NISuppressor(2, 0, NumericInt.Divides.class);
4106  private static NISuppressor arg1_divides_arg2 =
4107      new NISuppressor(0, 2, NumericInt.Divides.class);
4108
4109  private static NISuppressor arg2_valid_shift =
4110      new NISuppressor(0, RangeInt.Bound0_63.class);
4111
4112    private static NISuppressionSet suppressions =
4113      new NISuppressionSet(
4114          new NISuppression[] {
4115
4116            // (r == 0) && (z < x) && (z >= 0) && (x != 0) ==> r = z / x
4117            new NISuppression(result_eq_0, arg1_lt_arg2, arg1_ge_0, arg2_ne_0, suppressee),
4118
4119            // (z == x) && (x != 0) && (r == 1)
4120            new NISuppression(arg1_eq_arg2, arg2_ne_0, result_eq_1, suppressee),
4121
4122            // (r == z) && (x == 1) ==> r = z / x
4123            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
4124          });
4125
4126  // Create a suppression factory for functionBinary
4127
4128}
4129
4130/**
4131 * Represents the invariant {@code z = Division(y, x)} over three long
4132 * scalars. 
4133 */
4134public static class DivisionLong_zyx extends FunctionBinary {
4135  // We are Serializable, so we specify a version to allow changes to
4136  // method signatures without breaking serialization.  If you add or
4137  // remove fields, you should change this number to the current date.
4138  static final long serialVersionUID = 20031030L;
4139
4140  private static @Prototype DivisionLong_zyx proto = new @Prototype DivisionLong_zyx ();
4141
4142  /** Returns the prototype invariant for DivisionLong_zyx */
4143  public static @Prototype DivisionLong_zyx get_proto() {
4144    return proto;
4145  }
4146
4147  /** instantiate an invariant on the specified slice */
4148  @Override
4149  protected DivisionLong_zyx instantiate_dyn(@Prototype DivisionLong_zyx this, PptSlice slice) {
4150    return new DivisionLong_zyx (slice);
4151  }
4152
4153  private DivisionLong_zyx (PptSlice slice) {
4154    super(slice);
4155  }
4156
4157  public @Prototype DivisionLong_zyx () {
4158    super();
4159  }
4160
4161  private static String[] method_name = new String[] {"", " / ", ""};
4162
4163  @Override
4164  public String[] get_method_name(@GuardSatisfied DivisionLong_zyx this) {
4165    return method_name;
4166  }
4167
4168  private static int function_id = -1;
4169
4170  @Override
4171  public int get_function_id() {
4172    return function_id;
4173  }
4174
4175  @Override
4176  public void set_function_id(int function_id) {
4177    assert DivisionLong_zyx.function_id == -1;
4178    DivisionLong_zyx.function_id = function_id;
4179  }
4180
4181  private static int var_order = 6;
4182
4183  @Override
4184  public int get_var_order(@GuardSatisfied DivisionLong_zyx this) {
4185    return var_order;
4186  }
4187
4188  @Pure
4189  @Override
4190  public boolean is_symmetric() {
4191
4192      return false;
4193  }
4194
4195  @Override
4196
4197  public long func(long y, long x) {
4198
4199    return (y / x);
4200  }
4201
4202  @Override
4203  public InvariantStatus check_modified(long x, long y,
4204                                      long z, int count) {
4205    return check_ordered(z, y, x, count);
4206  }
4207
4208  @Override
4209  public InvariantStatus add_modified(long x, long y,
4210                                      long z, int count) {
4211    if (Debug.logDetail()) {
4212      log("result=%s, arg1=%s, arg2=%s", z, y, x);
4213    }
4214    return add_ordered(z, y, x, count);
4215  }
4216
4217  @Pure
4218  @Override
4219  public boolean isDivision() {
4220    return true;
4221  }
4222
4223  @Pure
4224  @Override
4225  public boolean isExact() {
4226    return true;
4227  }
4228
4229  /** Returns a list of non-instantiating suppressions for this invariant. */
4230  @Pure
4231  @Override
4232  public @Nullable NISuppressionSet get_ni_suppressions() {
4233    if (NIS.dkconfig_enabled && dkconfig_enabled) {
4234      return suppressions;
4235    } else {
4236      return null;
4237    }
4238  }
4239
4240  /** definition of this invariant (the suppressee) */
4241  private static NISuppressee suppressee = new NISuppressee(DivisionLong_zyx.class, 3);
4242
4243  // suppressor definitions (used below)
4244  private static NISuppressor result_eq_arg1 =
4245      new NISuppressor(2, 1, IntEqual.class);
4246  private static NISuppressor result_eq_arg2 =
4247      new NISuppressor(2, 0, IntEqual.class);
4248  private static NISuppressor arg1_eq_arg2 =
4249      new NISuppressor(1, 0, IntEqual.class);
4250
4251  private static NISuppressor result_lt_arg1 =
4252      new NISuppressor(2, 1, IntLessThan.class);
4253  private static NISuppressor result_lt_arg2 =
4254      new NISuppressor(2, 0, IntLessThan.class);
4255  private static NISuppressor arg1_lt_arg2 =
4256      new NISuppressor(1, 0, IntLessThan.class);
4257  private static NISuppressor arg2_lt_arg1 =
4258      new NISuppressor(0, 1, IntLessThan.class);
4259
4260  private static NISuppressor result_le_arg1 =
4261      new NISuppressor(2, 1, IntLessEqual.class);
4262  private static NISuppressor result_le_arg2 =
4263      new NISuppressor(2, 0, IntLessEqual.class);
4264  private static NISuppressor arg1_le_arg2 =
4265      new NISuppressor(1, 0, IntLessEqual.class);
4266  private static NISuppressor arg2_le_arg1 =
4267      new NISuppressor(0, 1, IntLessEqual.class);
4268
4269  private static NISuppressor result_track0_arg1 =
4270      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
4271  private static NISuppressor result_track0_arg2 =
4272      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
4273  private static NISuppressor arg1_track0_arg2 =
4274      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
4275  private static NISuppressor arg1_track0_result =
4276      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
4277  private static NISuppressor arg2_track0_result =
4278      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
4279  private static NISuppressor arg2_track0_arg1 =
4280      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
4281
4282  private static NISuppressor result_eq_1 =
4283      new NISuppressor(2, RangeInt.EqualOne.class);
4284  private static NISuppressor arg1_eq_1 =
4285      new NISuppressor(1, RangeInt.EqualOne.class);
4286  private static NISuppressor arg2_eq_1 =
4287      new NISuppressor(0, RangeInt.EqualOne.class);
4288
4289  private static NISuppressor result_eq_0 =
4290      new NISuppressor(2, RangeInt.EqualZero.class);
4291  private static NISuppressor arg1_eq_0 =
4292      new NISuppressor(1, RangeInt.EqualZero.class);
4293  private static NISuppressor arg2_eq_0 =
4294      new NISuppressor(0, RangeInt.EqualZero.class);
4295
4296  private static NISuppressor result_ne_0 =
4297      new NISuppressor(2, NonZero.class);
4298  private static NISuppressor arg1_ne_0 =
4299      new NISuppressor(1, NonZero.class);
4300  private static NISuppressor arg2_ne_0 =
4301      new NISuppressor(0, NonZero.class);
4302
4303  private static NISuppressor result_ge_0 =
4304      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
4305  private static NISuppressor arg1_ge_0 =
4306      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
4307  private static NISuppressor arg2_ge_0 =
4308      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
4309
4310  private static NISuppressor result_ge_64 =
4311      new NISuppressor(2, RangeInt.GreaterEqual64.class);
4312  private static NISuppressor arg1_ge_64 =
4313      new NISuppressor(1, RangeInt.GreaterEqual64.class);
4314  private static NISuppressor arg2_ge_64 =
4315      new NISuppressor(0, RangeInt.GreaterEqual64.class);
4316
4317  private static NISuppressor result_boolean =
4318      new NISuppressor(2, RangeInt.BooleanVal.class);
4319  private static NISuppressor arg1_boolean =
4320      new NISuppressor(1, RangeInt.BooleanVal.class);
4321  private static NISuppressor arg2_boolean =
4322      new NISuppressor(0, RangeInt.BooleanVal.class);
4323
4324  private static NISuppressor result_even =
4325      new NISuppressor(2, RangeInt.Even.class);
4326  private static NISuppressor arg1_even =
4327      new NISuppressor(1, RangeInt.Even.class);
4328  private static NISuppressor arg2_even =
4329      new NISuppressor(0, RangeInt.Even.class);
4330
4331  private static NISuppressor result_power2 =
4332      new NISuppressor(2, RangeInt.PowerOfTwo.class);
4333  private static NISuppressor arg1_power2 =
4334      new NISuppressor(1, RangeInt.PowerOfTwo.class);
4335  private static NISuppressor arg2_power2 =
4336      new NISuppressor(0, RangeInt.PowerOfTwo.class);
4337
4338  private static NISuppressor result_and0_arg1 =
4339      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
4340  private static NISuppressor result_and0_arg2 =
4341      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
4342  private static NISuppressor arg1_and0_arg2 =
4343      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
4344
4345  // The arguments to bitwise subset are backwards from what one
4346  // might expect.  The second argument is a subset of the first
4347  // argument
4348  private static NISuppressor arg1_bw_subset_arg2 =
4349      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
4350  private static NISuppressor arg2_bw_subset_arg1 =
4351      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
4352
4353  private static NISuppressor result_shift0_arg1 =
4354      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
4355  private static NISuppressor result_shift0_arg2 =
4356      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
4357  private static NISuppressor arg1_shift0_arg2 =
4358      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
4359
4360  private static NISuppressor arg2_divides_arg1 =
4361      new NISuppressor(1, 0, NumericInt.Divides.class);
4362  private static NISuppressor arg1_divides_arg2 =
4363      new NISuppressor(0, 1, NumericInt.Divides.class);
4364
4365  private static NISuppressor arg2_valid_shift =
4366      new NISuppressor(0, RangeInt.Bound0_63.class);
4367
4368    private static NISuppressionSet suppressions =
4369      new NISuppressionSet(
4370          new NISuppression[] {
4371
4372            // (r == 0) && (y < x) && (y >= 0) && (x != 0) ==> r = y / x
4373            new NISuppression(result_eq_0, arg1_lt_arg2, arg1_ge_0, arg2_ne_0, suppressee),
4374
4375            // (y == x) && (x != 0) && (r == 1)
4376            new NISuppression(arg1_eq_arg2, arg2_ne_0, result_eq_1, suppressee),
4377
4378            // (r == y) && (x == 1) ==> r = y / x
4379            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
4380          });
4381
4382  // Create a suppression factory for functionBinary
4383
4384}
4385
4386  // default is that it is not this function, overriden in the subclass
4387  @Pure
4388  public boolean isPower() {
4389    return false;
4390  }
4391
4392/**
4393 * Represents the invariant {@code x = Power(y, z)} over three long
4394 * scalars. 
4395 */
4396public static class PowerLong_xyz extends FunctionBinary {
4397  // We are Serializable, so we specify a version to allow changes to
4398  // method signatures without breaking serialization.  If you add or
4399  // remove fields, you should change this number to the current date.
4400  static final long serialVersionUID = 20031030L;
4401
4402  private static @Prototype PowerLong_xyz proto = new @Prototype PowerLong_xyz ();
4403
4404  /** Returns the prototype invariant for PowerLong_xyz */
4405  public static @Prototype PowerLong_xyz get_proto() {
4406    return proto;
4407  }
4408
4409  /** instantiate an invariant on the specified slice */
4410  @Override
4411  protected PowerLong_xyz instantiate_dyn(@Prototype PowerLong_xyz this, PptSlice slice) {
4412    return new PowerLong_xyz (slice);
4413  }
4414
4415  private PowerLong_xyz (PptSlice slice) {
4416    super(slice);
4417  }
4418
4419  public @Prototype PowerLong_xyz () {
4420    super();
4421  }
4422
4423  private static String[] method_name = new String[] {"java.lang.Math.pow(", ", ", ")"};
4424
4425  @Override
4426  public String[] get_method_name(@GuardSatisfied PowerLong_xyz this) {
4427    return method_name;
4428  }
4429
4430  private static int function_id = -1;
4431
4432  @Override
4433  public int get_function_id() {
4434    return function_id;
4435  }
4436
4437  @Override
4438  public void set_function_id(int function_id) {
4439    assert PowerLong_xyz.function_id == -1;
4440    PowerLong_xyz.function_id = function_id;
4441  }
4442
4443  private static int var_order = 1;
4444
4445  @Override
4446  public int get_var_order(@GuardSatisfied PowerLong_xyz this) {
4447    return var_order;
4448  }
4449
4450  @Pure
4451  @Override
4452  public boolean is_symmetric() {
4453
4454      return false;
4455  }
4456
4457  @Override
4458
4459  public long func(long y, long z) {
4460
4461    return MathPlume.pow(y, z);
4462  }
4463
4464  @Override
4465  public InvariantStatus check_modified(long x, long y,
4466                                      long z, int count) {
4467    return check_ordered(x, y, z, count);
4468  }
4469
4470  @Override
4471  public InvariantStatus add_modified(long x, long y,
4472                                      long z, int count) {
4473    if (Debug.logDetail()) {
4474      log("result=%s, arg1=%s, arg2=%s", x, y, z);
4475    }
4476    return add_ordered(x, y, z, count);
4477  }
4478
4479  @Pure
4480  @Override
4481  public boolean isPower() {
4482    return true;
4483  }
4484
4485  @Pure
4486  @Override
4487  public boolean isExact() {
4488    return true;
4489  }
4490
4491  /** Returns a list of non-instantiating suppressions for this invariant. */
4492  @Pure
4493  @Override
4494  public @Nullable NISuppressionSet get_ni_suppressions() {
4495    if (NIS.dkconfig_enabled && dkconfig_enabled) {
4496      return suppressions;
4497    } else {
4498      return null;
4499    }
4500  }
4501
4502  /** definition of this invariant (the suppressee) */
4503  private static NISuppressee suppressee = new NISuppressee(PowerLong_xyz.class, 3);
4504
4505  // suppressor definitions (used below)
4506  private static NISuppressor result_eq_arg1 =
4507      new NISuppressor(0, 1, IntEqual.class);
4508  private static NISuppressor result_eq_arg2 =
4509      new NISuppressor(0, 2, IntEqual.class);
4510  private static NISuppressor arg1_eq_arg2 =
4511      new NISuppressor(1, 2, IntEqual.class);
4512
4513  private static NISuppressor result_lt_arg1 =
4514      new NISuppressor(0, 1, IntLessThan.class);
4515  private static NISuppressor result_lt_arg2 =
4516      new NISuppressor(0, 2, IntLessThan.class);
4517  private static NISuppressor arg1_lt_arg2 =
4518      new NISuppressor(1, 2, IntLessThan.class);
4519  private static NISuppressor arg2_lt_arg1 =
4520      new NISuppressor(2, 1, IntLessThan.class);
4521
4522  private static NISuppressor result_le_arg1 =
4523      new NISuppressor(0, 1, IntLessEqual.class);
4524  private static NISuppressor result_le_arg2 =
4525      new NISuppressor(0, 2, IntLessEqual.class);
4526  private static NISuppressor arg1_le_arg2 =
4527      new NISuppressor(1, 2, IntLessEqual.class);
4528  private static NISuppressor arg2_le_arg1 =
4529      new NISuppressor(2, 1, IntLessEqual.class);
4530
4531  private static NISuppressor result_track0_arg1 =
4532      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
4533  private static NISuppressor result_track0_arg2 =
4534      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
4535  private static NISuppressor arg1_track0_arg2 =
4536      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
4537  private static NISuppressor arg1_track0_result =
4538      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
4539  private static NISuppressor arg2_track0_result =
4540      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
4541  private static NISuppressor arg2_track0_arg1 =
4542      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
4543
4544  private static NISuppressor result_eq_1 =
4545      new NISuppressor(0, RangeInt.EqualOne.class);
4546  private static NISuppressor arg1_eq_1 =
4547      new NISuppressor(1, RangeInt.EqualOne.class);
4548  private static NISuppressor arg2_eq_1 =
4549      new NISuppressor(2, RangeInt.EqualOne.class);
4550
4551  private static NISuppressor result_eq_0 =
4552      new NISuppressor(0, RangeInt.EqualZero.class);
4553  private static NISuppressor arg1_eq_0 =
4554      new NISuppressor(1, RangeInt.EqualZero.class);
4555  private static NISuppressor arg2_eq_0 =
4556      new NISuppressor(2, RangeInt.EqualZero.class);
4557
4558  private static NISuppressor result_ne_0 =
4559      new NISuppressor(0, NonZero.class);
4560  private static NISuppressor arg1_ne_0 =
4561      new NISuppressor(1, NonZero.class);
4562  private static NISuppressor arg2_ne_0 =
4563      new NISuppressor(2, NonZero.class);
4564
4565  private static NISuppressor result_ge_0 =
4566      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
4567  private static NISuppressor arg1_ge_0 =
4568      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
4569  private static NISuppressor arg2_ge_0 =
4570      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
4571
4572  private static NISuppressor result_ge_64 =
4573      new NISuppressor(0, RangeInt.GreaterEqual64.class);
4574  private static NISuppressor arg1_ge_64 =
4575      new NISuppressor(1, RangeInt.GreaterEqual64.class);
4576  private static NISuppressor arg2_ge_64 =
4577      new NISuppressor(2, RangeInt.GreaterEqual64.class);
4578
4579  private static NISuppressor result_boolean =
4580      new NISuppressor(0, RangeInt.BooleanVal.class);
4581  private static NISuppressor arg1_boolean =
4582      new NISuppressor(1, RangeInt.BooleanVal.class);
4583  private static NISuppressor arg2_boolean =
4584      new NISuppressor(2, RangeInt.BooleanVal.class);
4585
4586  private static NISuppressor result_even =
4587      new NISuppressor(0, RangeInt.Even.class);
4588  private static NISuppressor arg1_even =
4589      new NISuppressor(1, RangeInt.Even.class);
4590  private static NISuppressor arg2_even =
4591      new NISuppressor(2, RangeInt.Even.class);
4592
4593  private static NISuppressor result_power2 =
4594      new NISuppressor(0, RangeInt.PowerOfTwo.class);
4595  private static NISuppressor arg1_power2 =
4596      new NISuppressor(1, RangeInt.PowerOfTwo.class);
4597  private static NISuppressor arg2_power2 =
4598      new NISuppressor(2, RangeInt.PowerOfTwo.class);
4599
4600  private static NISuppressor result_and0_arg1 =
4601      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
4602  private static NISuppressor result_and0_arg2 =
4603      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
4604  private static NISuppressor arg1_and0_arg2 =
4605      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
4606
4607  // The arguments to bitwise subset are backwards from what one
4608  // might expect.  The second argument is a subset of the first
4609  // argument
4610  private static NISuppressor arg1_bw_subset_arg2 =
4611      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
4612  private static NISuppressor arg2_bw_subset_arg1 =
4613      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
4614
4615  private static NISuppressor result_shift0_arg1 =
4616      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
4617  private static NISuppressor result_shift0_arg2 =
4618      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
4619  private static NISuppressor arg1_shift0_arg2 =
4620      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
4621
4622  private static NISuppressor arg2_divides_arg1 =
4623      new NISuppressor(1, 2, NumericInt.Divides.class);
4624  private static NISuppressor arg1_divides_arg2 =
4625      new NISuppressor(2, 1, NumericInt.Divides.class);
4626
4627  private static NISuppressor arg2_valid_shift =
4628      new NISuppressor(2, RangeInt.Bound0_63.class);
4629
4630    // Note that any suppression that doesn't limit z to valid exponents
4631    // (>= 0), must check for valid exponents as well (so that the invariant
4632    // is correctly destroyed on invalid exponents)
4633    //
4634    // Note also that pow(0,0) == 1 and pow(0,x), where (x > 0), == 0
4635    // Another interesting artificat of pow is that for any even base, any
4636    // exponent >= 64 will yield a result of 0.  For example, pow(10,256) == 0
4637    // (at least for integers)
4638
4639    private static NISuppressionSet suppressions =
4640      new NISuppressionSet(
4641          new NISuppression[] {
4642
4643            // (r == 1) && (z == 0) ==> r = pow (y, z)
4644            new NISuppression(result_eq_1, arg2_eq_0, suppressee),
4645
4646            // (r == 1) && (y == 1) && (z >= 0)   ==> r = pow (y, z)
4647            new NISuppression(result_eq_1, arg1_eq_1, arg2_ge_0, suppressee),
4648
4649            // (r == 0) && (y == 0) && (z > 0)
4650            new NISuppression(result_eq_0, arg1_eq_0, arg2_ne_0, arg2_ge_0,
4651                              suppressee),
4652
4653            // (r == y) && (z == 1)    ==> r = pow (y, z)
4654            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
4655
4656            // (r == 0) && (y even) && (z >= 64)
4657            // with each multiply there is one more zero in the result and since
4658            // a long has 64 bits in it, it becomes zero at that point
4659            new NISuppression(result_eq_0, arg1_even, arg2_ge_64, suppressee),
4660
4661            // (r == 1) && (y boolean) && (y==0 <==> z==0) && (z >= 0)
4662            // 1 = pow (0, z) true iff (z == 0)
4663            // 1 = pow (1, z) true when z valid exponent
4664            new NISuppression(arg1_track0_arg2, arg2_ge_0, arg1_boolean,
4665                               result_eq_1, suppressee),
4666
4667            // (r == y) && (r boolean) && (z > 0)
4668            // 0 = pow (0, z) true when z != 0
4669            // 1 = pow (1, z) true when z valid exponent
4670            new NISuppression(result_eq_arg1, result_boolean, arg2_ne_0,
4671                               arg2_ge_0, suppressee),
4672
4673          });
4674
4675  // Create a suppression factory for functionBinary
4676
4677}
4678
4679/**
4680 * Represents the invariant {@code y = Power(x, z)} over three long
4681 * scalars. 
4682 */
4683public static class PowerLong_yxz extends FunctionBinary {
4684  // We are Serializable, so we specify a version to allow changes to
4685  // method signatures without breaking serialization.  If you add or
4686  // remove fields, you should change this number to the current date.
4687  static final long serialVersionUID = 20031030L;
4688
4689  private static @Prototype PowerLong_yxz proto = new @Prototype PowerLong_yxz ();
4690
4691  /** Returns the prototype invariant for PowerLong_yxz */
4692  public static @Prototype PowerLong_yxz get_proto() {
4693    return proto;
4694  }
4695
4696  /** instantiate an invariant on the specified slice */
4697  @Override
4698  protected PowerLong_yxz instantiate_dyn(@Prototype PowerLong_yxz this, PptSlice slice) {
4699    return new PowerLong_yxz (slice);
4700  }
4701
4702  private PowerLong_yxz (PptSlice slice) {
4703    super(slice);
4704  }
4705
4706  public @Prototype PowerLong_yxz () {
4707    super();
4708  }
4709
4710  private static String[] method_name = new String[] {"java.lang.Math.pow(", ", ", ")"};
4711
4712  @Override
4713  public String[] get_method_name(@GuardSatisfied PowerLong_yxz this) {
4714    return method_name;
4715  }
4716
4717  private static int function_id = -1;
4718
4719  @Override
4720  public int get_function_id() {
4721    return function_id;
4722  }
4723
4724  @Override
4725  public void set_function_id(int function_id) {
4726    assert PowerLong_yxz.function_id == -1;
4727    PowerLong_yxz.function_id = function_id;
4728  }
4729
4730  private static int var_order = 2;
4731
4732  @Override
4733  public int get_var_order(@GuardSatisfied PowerLong_yxz this) {
4734    return var_order;
4735  }
4736
4737  @Pure
4738  @Override
4739  public boolean is_symmetric() {
4740
4741      return false;
4742  }
4743
4744  @Override
4745
4746  public long func(long x, long z) {
4747
4748    return MathPlume.pow(x, z);
4749  }
4750
4751  @Override
4752  public InvariantStatus check_modified(long x, long y,
4753                                      long z, int count) {
4754    return check_ordered(y, x, z, count);
4755  }
4756
4757  @Override
4758  public InvariantStatus add_modified(long x, long y,
4759                                      long z, int count) {
4760    if (Debug.logDetail()) {
4761      log("result=%s, arg1=%s, arg2=%s", y, x, z);
4762    }
4763    return add_ordered(y, x, z, count);
4764  }
4765
4766  @Pure
4767  @Override
4768  public boolean isPower() {
4769    return true;
4770  }
4771
4772  @Pure
4773  @Override
4774  public boolean isExact() {
4775    return true;
4776  }
4777
4778  /** Returns a list of non-instantiating suppressions for this invariant. */
4779  @Pure
4780  @Override
4781  public @Nullable NISuppressionSet get_ni_suppressions() {
4782    if (NIS.dkconfig_enabled && dkconfig_enabled) {
4783      return suppressions;
4784    } else {
4785      return null;
4786    }
4787  }
4788
4789  /** definition of this invariant (the suppressee) */
4790  private static NISuppressee suppressee = new NISuppressee(PowerLong_yxz.class, 3);
4791
4792  // suppressor definitions (used below)
4793  private static NISuppressor result_eq_arg1 =
4794      new NISuppressor(1, 0, IntEqual.class);
4795  private static NISuppressor result_eq_arg2 =
4796      new NISuppressor(1, 2, IntEqual.class);
4797  private static NISuppressor arg1_eq_arg2 =
4798      new NISuppressor(0, 2, IntEqual.class);
4799
4800  private static NISuppressor result_lt_arg1 =
4801      new NISuppressor(1, 0, IntLessThan.class);
4802  private static NISuppressor result_lt_arg2 =
4803      new NISuppressor(1, 2, IntLessThan.class);
4804  private static NISuppressor arg1_lt_arg2 =
4805      new NISuppressor(0, 2, IntLessThan.class);
4806  private static NISuppressor arg2_lt_arg1 =
4807      new NISuppressor(2, 0, IntLessThan.class);
4808
4809  private static NISuppressor result_le_arg1 =
4810      new NISuppressor(1, 0, IntLessEqual.class);
4811  private static NISuppressor result_le_arg2 =
4812      new NISuppressor(1, 2, IntLessEqual.class);
4813  private static NISuppressor arg1_le_arg2 =
4814      new NISuppressor(0, 2, IntLessEqual.class);
4815  private static NISuppressor arg2_le_arg1 =
4816      new NISuppressor(2, 0, IntLessEqual.class);
4817
4818  private static NISuppressor result_track0_arg1 =
4819      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
4820  private static NISuppressor result_track0_arg2 =
4821      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
4822  private static NISuppressor arg1_track0_arg2 =
4823      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
4824  private static NISuppressor arg1_track0_result =
4825      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
4826  private static NISuppressor arg2_track0_result =
4827      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
4828  private static NISuppressor arg2_track0_arg1 =
4829      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
4830
4831  private static NISuppressor result_eq_1 =
4832      new NISuppressor(1, RangeInt.EqualOne.class);
4833  private static NISuppressor arg1_eq_1 =
4834      new NISuppressor(0, RangeInt.EqualOne.class);
4835  private static NISuppressor arg2_eq_1 =
4836      new NISuppressor(2, RangeInt.EqualOne.class);
4837
4838  private static NISuppressor result_eq_0 =
4839      new NISuppressor(1, RangeInt.EqualZero.class);
4840  private static NISuppressor arg1_eq_0 =
4841      new NISuppressor(0, RangeInt.EqualZero.class);
4842  private static NISuppressor arg2_eq_0 =
4843      new NISuppressor(2, RangeInt.EqualZero.class);
4844
4845  private static NISuppressor result_ne_0 =
4846      new NISuppressor(1, NonZero.class);
4847  private static NISuppressor arg1_ne_0 =
4848      new NISuppressor(0, NonZero.class);
4849  private static NISuppressor arg2_ne_0 =
4850      new NISuppressor(2, NonZero.class);
4851
4852  private static NISuppressor result_ge_0 =
4853      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
4854  private static NISuppressor arg1_ge_0 =
4855      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
4856  private static NISuppressor arg2_ge_0 =
4857      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
4858
4859  private static NISuppressor result_ge_64 =
4860      new NISuppressor(1, RangeInt.GreaterEqual64.class);
4861  private static NISuppressor arg1_ge_64 =
4862      new NISuppressor(0, RangeInt.GreaterEqual64.class);
4863  private static NISuppressor arg2_ge_64 =
4864      new NISuppressor(2, RangeInt.GreaterEqual64.class);
4865
4866  private static NISuppressor result_boolean =
4867      new NISuppressor(1, RangeInt.BooleanVal.class);
4868  private static NISuppressor arg1_boolean =
4869      new NISuppressor(0, RangeInt.BooleanVal.class);
4870  private static NISuppressor arg2_boolean =
4871      new NISuppressor(2, RangeInt.BooleanVal.class);
4872
4873  private static NISuppressor result_even =
4874      new NISuppressor(1, RangeInt.Even.class);
4875  private static NISuppressor arg1_even =
4876      new NISuppressor(0, RangeInt.Even.class);
4877  private static NISuppressor arg2_even =
4878      new NISuppressor(2, RangeInt.Even.class);
4879
4880  private static NISuppressor result_power2 =
4881      new NISuppressor(1, RangeInt.PowerOfTwo.class);
4882  private static NISuppressor arg1_power2 =
4883      new NISuppressor(0, RangeInt.PowerOfTwo.class);
4884  private static NISuppressor arg2_power2 =
4885      new NISuppressor(2, RangeInt.PowerOfTwo.class);
4886
4887  private static NISuppressor result_and0_arg1 =
4888      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
4889  private static NISuppressor result_and0_arg2 =
4890      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
4891  private static NISuppressor arg1_and0_arg2 =
4892      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
4893
4894  // The arguments to bitwise subset are backwards from what one
4895  // might expect.  The second argument is a subset of the first
4896  // argument
4897  private static NISuppressor arg1_bw_subset_arg2 =
4898      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
4899  private static NISuppressor arg2_bw_subset_arg1 =
4900      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
4901
4902  private static NISuppressor result_shift0_arg1 =
4903      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
4904  private static NISuppressor result_shift0_arg2 =
4905      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
4906  private static NISuppressor arg1_shift0_arg2 =
4907      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
4908
4909  private static NISuppressor arg2_divides_arg1 =
4910      new NISuppressor(0, 2, NumericInt.Divides.class);
4911  private static NISuppressor arg1_divides_arg2 =
4912      new NISuppressor(2, 0, NumericInt.Divides.class);
4913
4914  private static NISuppressor arg2_valid_shift =
4915      new NISuppressor(2, RangeInt.Bound0_63.class);
4916
4917    // Note that any suppression that doesn't limit z to valid exponents
4918    // (>= 0), must check for valid exponents as well (so that the invariant
4919    // is correctly destroyed on invalid exponents)
4920    //
4921    // Note also that pow(0,0) == 1 and pow(0,x), where (x > 0), == 0
4922    // Another interesting artificat of pow is that for any even base, any
4923    // exponent >= 64 will yield a result of 0.  For example, pow(10,256) == 0
4924    // (at least for integers)
4925
4926    private static NISuppressionSet suppressions =
4927      new NISuppressionSet(
4928          new NISuppression[] {
4929
4930            // (r == 1) && (z == 0) ==> r = pow (x, z)
4931            new NISuppression(result_eq_1, arg2_eq_0, suppressee),
4932
4933            // (r == 1) && (x == 1) && (z >= 0)   ==> r = pow (x, z)
4934            new NISuppression(result_eq_1, arg1_eq_1, arg2_ge_0, suppressee),
4935
4936            // (r == 0) && (x == 0) && (z > 0)
4937            new NISuppression(result_eq_0, arg1_eq_0, arg2_ne_0, arg2_ge_0,
4938                              suppressee),
4939
4940            // (r == x) && (z == 1)    ==> r = pow (x, z)
4941            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
4942
4943            // (r == 0) && (x even) && (z >= 64)
4944            // with each multiply there is one more zero in the result and since
4945            // a long has 64 bits in it, it becomes zero at that point
4946            new NISuppression(result_eq_0, arg1_even, arg2_ge_64, suppressee),
4947
4948            // (r == 1) && (x boolean) && (x==0 <==> z==0) && (z >= 0)
4949            // 1 = pow (0, z) true iff (z == 0)
4950            // 1 = pow (1, z) true when z valid exponent
4951            new NISuppression(arg1_track0_arg2, arg2_ge_0, arg1_boolean,
4952                               result_eq_1, suppressee),
4953
4954            // (r == x) && (r boolean) && (z > 0)
4955            // 0 = pow (0, z) true when z != 0
4956            // 1 = pow (1, z) true when z valid exponent
4957            new NISuppression(result_eq_arg1, result_boolean, arg2_ne_0,
4958                               arg2_ge_0, suppressee),
4959
4960          });
4961
4962  // Create a suppression factory for functionBinary
4963
4964}
4965
4966/**
4967 * Represents the invariant {@code z = Power(x, y)} over three long
4968 * scalars. 
4969 */
4970public static class PowerLong_zxy extends FunctionBinary {
4971  // We are Serializable, so we specify a version to allow changes to
4972  // method signatures without breaking serialization.  If you add or
4973  // remove fields, you should change this number to the current date.
4974  static final long serialVersionUID = 20031030L;
4975
4976  private static @Prototype PowerLong_zxy proto = new @Prototype PowerLong_zxy ();
4977
4978  /** Returns the prototype invariant for PowerLong_zxy */
4979  public static @Prototype PowerLong_zxy get_proto() {
4980    return proto;
4981  }
4982
4983  /** instantiate an invariant on the specified slice */
4984  @Override
4985  protected PowerLong_zxy instantiate_dyn(@Prototype PowerLong_zxy this, PptSlice slice) {
4986    return new PowerLong_zxy (slice);
4987  }
4988
4989  private PowerLong_zxy (PptSlice slice) {
4990    super(slice);
4991  }
4992
4993  public @Prototype PowerLong_zxy () {
4994    super();
4995  }
4996
4997  private static String[] method_name = new String[] {"java.lang.Math.pow(", ", ", ")"};
4998
4999  @Override
5000  public String[] get_method_name(@GuardSatisfied PowerLong_zxy this) {
5001    return method_name;
5002  }
5003
5004  private static int function_id = -1;
5005
5006  @Override
5007  public int get_function_id() {
5008    return function_id;
5009  }
5010
5011  @Override
5012  public void set_function_id(int function_id) {
5013    assert PowerLong_zxy.function_id == -1;
5014    PowerLong_zxy.function_id = function_id;
5015  }
5016
5017  private static int var_order = 3;
5018
5019  @Override
5020  public int get_var_order(@GuardSatisfied PowerLong_zxy this) {
5021    return var_order;
5022  }
5023
5024  @Pure
5025  @Override
5026  public boolean is_symmetric() {
5027
5028      return false;
5029  }
5030
5031  @Override
5032
5033  public long func(long x, long y) {
5034
5035    return MathPlume.pow(x, y);
5036  }
5037
5038  @Override
5039  public InvariantStatus check_modified(long x, long y,
5040                                      long z, int count) {
5041    return check_ordered(z, x, y, count);
5042  }
5043
5044  @Override
5045  public InvariantStatus add_modified(long x, long y,
5046                                      long z, int count) {
5047    if (Debug.logDetail()) {
5048      log("result=%s, arg1=%s, arg2=%s", z, x, y);
5049    }
5050    return add_ordered(z, x, y, count);
5051  }
5052
5053  @Pure
5054  @Override
5055  public boolean isPower() {
5056    return true;
5057  }
5058
5059  @Pure
5060  @Override
5061  public boolean isExact() {
5062    return true;
5063  }
5064
5065  /** Returns a list of non-instantiating suppressions for this invariant. */
5066  @Pure
5067  @Override
5068  public @Nullable NISuppressionSet get_ni_suppressions() {
5069    if (NIS.dkconfig_enabled && dkconfig_enabled) {
5070      return suppressions;
5071    } else {
5072      return null;
5073    }
5074  }
5075
5076  /** definition of this invariant (the suppressee) */
5077  private static NISuppressee suppressee = new NISuppressee(PowerLong_zxy.class, 3);
5078
5079  // suppressor definitions (used below)
5080  private static NISuppressor result_eq_arg1 =
5081      new NISuppressor(2, 0, IntEqual.class);
5082  private static NISuppressor result_eq_arg2 =
5083      new NISuppressor(2, 1, IntEqual.class);
5084  private static NISuppressor arg1_eq_arg2 =
5085      new NISuppressor(0, 1, IntEqual.class);
5086
5087  private static NISuppressor result_lt_arg1 =
5088      new NISuppressor(2, 0, IntLessThan.class);
5089  private static NISuppressor result_lt_arg2 =
5090      new NISuppressor(2, 1, IntLessThan.class);
5091  private static NISuppressor arg1_lt_arg2 =
5092      new NISuppressor(0, 1, IntLessThan.class);
5093  private static NISuppressor arg2_lt_arg1 =
5094      new NISuppressor(1, 0, IntLessThan.class);
5095
5096  private static NISuppressor result_le_arg1 =
5097      new NISuppressor(2, 0, IntLessEqual.class);
5098  private static NISuppressor result_le_arg2 =
5099      new NISuppressor(2, 1, IntLessEqual.class);
5100  private static NISuppressor arg1_le_arg2 =
5101      new NISuppressor(0, 1, IntLessEqual.class);
5102  private static NISuppressor arg2_le_arg1 =
5103      new NISuppressor(1, 0, IntLessEqual.class);
5104
5105  private static NISuppressor result_track0_arg1 =
5106      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
5107  private static NISuppressor result_track0_arg2 =
5108      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
5109  private static NISuppressor arg1_track0_arg2 =
5110      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
5111  private static NISuppressor arg1_track0_result =
5112      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
5113  private static NISuppressor arg2_track0_result =
5114      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
5115  private static NISuppressor arg2_track0_arg1 =
5116      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
5117
5118  private static NISuppressor result_eq_1 =
5119      new NISuppressor(2, RangeInt.EqualOne.class);
5120  private static NISuppressor arg1_eq_1 =
5121      new NISuppressor(0, RangeInt.EqualOne.class);
5122  private static NISuppressor arg2_eq_1 =
5123      new NISuppressor(1, RangeInt.EqualOne.class);
5124
5125  private static NISuppressor result_eq_0 =
5126      new NISuppressor(2, RangeInt.EqualZero.class);
5127  private static NISuppressor arg1_eq_0 =
5128      new NISuppressor(0, RangeInt.EqualZero.class);
5129  private static NISuppressor arg2_eq_0 =
5130      new NISuppressor(1, RangeInt.EqualZero.class);
5131
5132  private static NISuppressor result_ne_0 =
5133      new NISuppressor(2, NonZero.class);
5134  private static NISuppressor arg1_ne_0 =
5135      new NISuppressor(0, NonZero.class);
5136  private static NISuppressor arg2_ne_0 =
5137      new NISuppressor(1, NonZero.class);
5138
5139  private static NISuppressor result_ge_0 =
5140      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
5141  private static NISuppressor arg1_ge_0 =
5142      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
5143  private static NISuppressor arg2_ge_0 =
5144      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
5145
5146  private static NISuppressor result_ge_64 =
5147      new NISuppressor(2, RangeInt.GreaterEqual64.class);
5148  private static NISuppressor arg1_ge_64 =
5149      new NISuppressor(0, RangeInt.GreaterEqual64.class);
5150  private static NISuppressor arg2_ge_64 =
5151      new NISuppressor(1, RangeInt.GreaterEqual64.class);
5152
5153  private static NISuppressor result_boolean =
5154      new NISuppressor(2, RangeInt.BooleanVal.class);
5155  private static NISuppressor arg1_boolean =
5156      new NISuppressor(0, RangeInt.BooleanVal.class);
5157  private static NISuppressor arg2_boolean =
5158      new NISuppressor(1, RangeInt.BooleanVal.class);
5159
5160  private static NISuppressor result_even =
5161      new NISuppressor(2, RangeInt.Even.class);
5162  private static NISuppressor arg1_even =
5163      new NISuppressor(0, RangeInt.Even.class);
5164  private static NISuppressor arg2_even =
5165      new NISuppressor(1, RangeInt.Even.class);
5166
5167  private static NISuppressor result_power2 =
5168      new NISuppressor(2, RangeInt.PowerOfTwo.class);
5169  private static NISuppressor arg1_power2 =
5170      new NISuppressor(0, RangeInt.PowerOfTwo.class);
5171  private static NISuppressor arg2_power2 =
5172      new NISuppressor(1, RangeInt.PowerOfTwo.class);
5173
5174  private static NISuppressor result_and0_arg1 =
5175      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
5176  private static NISuppressor result_and0_arg2 =
5177      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
5178  private static NISuppressor arg1_and0_arg2 =
5179      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
5180
5181  // The arguments to bitwise subset are backwards from what one
5182  // might expect.  The second argument is a subset of the first
5183  // argument
5184  private static NISuppressor arg1_bw_subset_arg2 =
5185      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
5186  private static NISuppressor arg2_bw_subset_arg1 =
5187      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
5188
5189  private static NISuppressor result_shift0_arg1 =
5190      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
5191  private static NISuppressor result_shift0_arg2 =
5192      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
5193  private static NISuppressor arg1_shift0_arg2 =
5194      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
5195
5196  private static NISuppressor arg2_divides_arg1 =
5197      new NISuppressor(0, 1, NumericInt.Divides.class);
5198  private static NISuppressor arg1_divides_arg2 =
5199      new NISuppressor(1, 0, NumericInt.Divides.class);
5200
5201  private static NISuppressor arg2_valid_shift =
5202      new NISuppressor(1, RangeInt.Bound0_63.class);
5203
5204    // Note that any suppression that doesn't limit y to valid exponents
5205    // (>= 0), must check for valid exponents as well (so that the invariant
5206    // is correctly destroyed on invalid exponents)
5207    //
5208    // Note also that pow(0,0) == 1 and pow(0,x), where (x > 0), == 0
5209    // Another interesting artificat of pow is that for any even base, any
5210    // exponent >= 64 will yield a result of 0.  For example, pow(10,256) == 0
5211    // (at least for integers)
5212
5213    private static NISuppressionSet suppressions =
5214      new NISuppressionSet(
5215          new NISuppression[] {
5216
5217            // (r == 1) && (y == 0) ==> r = pow (x, y)
5218            new NISuppression(result_eq_1, arg2_eq_0, suppressee),
5219
5220            // (r == 1) && (x == 1) && (y >= 0)   ==> r = pow (x, y)
5221            new NISuppression(result_eq_1, arg1_eq_1, arg2_ge_0, suppressee),
5222
5223            // (r == 0) && (x == 0) && (y > 0)
5224            new NISuppression(result_eq_0, arg1_eq_0, arg2_ne_0, arg2_ge_0,
5225                              suppressee),
5226
5227            // (r == x) && (y == 1)    ==> r = pow (x, y)
5228            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
5229
5230            // (r == 0) && (x even) && (y >= 64)
5231            // with each multiply there is one more zero in the result and since
5232            // a long has 64 bits in it, it becomes zero at that point
5233            new NISuppression(result_eq_0, arg1_even, arg2_ge_64, suppressee),
5234
5235            // (r == 1) && (x boolean) && (x==0 <==> y==0) && (y >= 0)
5236            // 1 = pow (0, y) true iff (y == 0)
5237            // 1 = pow (1, y) true when y valid exponent
5238            new NISuppression(arg1_track0_arg2, arg2_ge_0, arg1_boolean,
5239                               result_eq_1, suppressee),
5240
5241            // (r == x) && (r boolean) && (y > 0)
5242            // 0 = pow (0, y) true when y != 0
5243            // 1 = pow (1, y) true when y valid exponent
5244            new NISuppression(result_eq_arg1, result_boolean, arg2_ne_0,
5245                               arg2_ge_0, suppressee),
5246
5247          });
5248
5249  // Create a suppression factory for functionBinary
5250
5251}
5252
5253/**
5254 * Represents the invariant {@code x = Power(z, y)} over three long
5255 * scalars. 
5256 */
5257public static class PowerLong_xzy extends FunctionBinary {
5258  // We are Serializable, so we specify a version to allow changes to
5259  // method signatures without breaking serialization.  If you add or
5260  // remove fields, you should change this number to the current date.
5261  static final long serialVersionUID = 20031030L;
5262
5263  private static @Prototype PowerLong_xzy proto = new @Prototype PowerLong_xzy ();
5264
5265  /** Returns the prototype invariant for PowerLong_xzy */
5266  public static @Prototype PowerLong_xzy get_proto() {
5267    return proto;
5268  }
5269
5270  /** instantiate an invariant on the specified slice */
5271  @Override
5272  protected PowerLong_xzy instantiate_dyn(@Prototype PowerLong_xzy this, PptSlice slice) {
5273    return new PowerLong_xzy (slice);
5274  }
5275
5276  private PowerLong_xzy (PptSlice slice) {
5277    super(slice);
5278  }
5279
5280  public @Prototype PowerLong_xzy () {
5281    super();
5282  }
5283
5284  private static String[] method_name = new String[] {"java.lang.Math.pow(", ", ", ")"};
5285
5286  @Override
5287  public String[] get_method_name(@GuardSatisfied PowerLong_xzy this) {
5288    return method_name;
5289  }
5290
5291  private static int function_id = -1;
5292
5293  @Override
5294  public int get_function_id() {
5295    return function_id;
5296  }
5297
5298  @Override
5299  public void set_function_id(int function_id) {
5300    assert PowerLong_xzy.function_id == -1;
5301    PowerLong_xzy.function_id = function_id;
5302  }
5303
5304  private static int var_order = 4;
5305
5306  @Override
5307  public int get_var_order(@GuardSatisfied PowerLong_xzy this) {
5308    return var_order;
5309  }
5310
5311  @Pure
5312  @Override
5313  public boolean is_symmetric() {
5314
5315      return false;
5316  }
5317
5318  @Override
5319
5320  public long func(long z, long y) {
5321
5322    return MathPlume.pow(z, y);
5323  }
5324
5325  @Override
5326  public InvariantStatus check_modified(long x, long y,
5327                                      long z, int count) {
5328    return check_ordered(x, z, y, count);
5329  }
5330
5331  @Override
5332  public InvariantStatus add_modified(long x, long y,
5333                                      long z, int count) {
5334    if (Debug.logDetail()) {
5335      log("result=%s, arg1=%s, arg2=%s", x, z, y);
5336    }
5337    return add_ordered(x, z, y, count);
5338  }
5339
5340  @Pure
5341  @Override
5342  public boolean isPower() {
5343    return true;
5344  }
5345
5346  @Pure
5347  @Override
5348  public boolean isExact() {
5349    return true;
5350  }
5351
5352  /** Returns a list of non-instantiating suppressions for this invariant. */
5353  @Pure
5354  @Override
5355  public @Nullable NISuppressionSet get_ni_suppressions() {
5356    if (NIS.dkconfig_enabled && dkconfig_enabled) {
5357      return suppressions;
5358    } else {
5359      return null;
5360    }
5361  }
5362
5363  /** definition of this invariant (the suppressee) */
5364  private static NISuppressee suppressee = new NISuppressee(PowerLong_xzy.class, 3);
5365
5366  // suppressor definitions (used below)
5367  private static NISuppressor result_eq_arg1 =
5368      new NISuppressor(0, 2, IntEqual.class);
5369  private static NISuppressor result_eq_arg2 =
5370      new NISuppressor(0, 1, IntEqual.class);
5371  private static NISuppressor arg1_eq_arg2 =
5372      new NISuppressor(2, 1, IntEqual.class);
5373
5374  private static NISuppressor result_lt_arg1 =
5375      new NISuppressor(0, 2, IntLessThan.class);
5376  private static NISuppressor result_lt_arg2 =
5377      new NISuppressor(0, 1, IntLessThan.class);
5378  private static NISuppressor arg1_lt_arg2 =
5379      new NISuppressor(2, 1, IntLessThan.class);
5380  private static NISuppressor arg2_lt_arg1 =
5381      new NISuppressor(1, 2, IntLessThan.class);
5382
5383  private static NISuppressor result_le_arg1 =
5384      new NISuppressor(0, 2, IntLessEqual.class);
5385  private static NISuppressor result_le_arg2 =
5386      new NISuppressor(0, 1, IntLessEqual.class);
5387  private static NISuppressor arg1_le_arg2 =
5388      new NISuppressor(2, 1, IntLessEqual.class);
5389  private static NISuppressor arg2_le_arg1 =
5390      new NISuppressor(1, 2, IntLessEqual.class);
5391
5392  private static NISuppressor result_track0_arg1 =
5393      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
5394  private static NISuppressor result_track0_arg2 =
5395      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
5396  private static NISuppressor arg1_track0_arg2 =
5397      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
5398  private static NISuppressor arg1_track0_result =
5399      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
5400  private static NISuppressor arg2_track0_result =
5401      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
5402  private static NISuppressor arg2_track0_arg1 =
5403      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
5404
5405  private static NISuppressor result_eq_1 =
5406      new NISuppressor(0, RangeInt.EqualOne.class);
5407  private static NISuppressor arg1_eq_1 =
5408      new NISuppressor(2, RangeInt.EqualOne.class);
5409  private static NISuppressor arg2_eq_1 =
5410      new NISuppressor(1, RangeInt.EqualOne.class);
5411
5412  private static NISuppressor result_eq_0 =
5413      new NISuppressor(0, RangeInt.EqualZero.class);
5414  private static NISuppressor arg1_eq_0 =
5415      new NISuppressor(2, RangeInt.EqualZero.class);
5416  private static NISuppressor arg2_eq_0 =
5417      new NISuppressor(1, RangeInt.EqualZero.class);
5418
5419  private static NISuppressor result_ne_0 =
5420      new NISuppressor(0, NonZero.class);
5421  private static NISuppressor arg1_ne_0 =
5422      new NISuppressor(2, NonZero.class);
5423  private static NISuppressor arg2_ne_0 =
5424      new NISuppressor(1, NonZero.class);
5425
5426  private static NISuppressor result_ge_0 =
5427      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
5428  private static NISuppressor arg1_ge_0 =
5429      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
5430  private static NISuppressor arg2_ge_0 =
5431      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
5432
5433  private static NISuppressor result_ge_64 =
5434      new NISuppressor(0, RangeInt.GreaterEqual64.class);
5435  private static NISuppressor arg1_ge_64 =
5436      new NISuppressor(2, RangeInt.GreaterEqual64.class);
5437  private static NISuppressor arg2_ge_64 =
5438      new NISuppressor(1, RangeInt.GreaterEqual64.class);
5439
5440  private static NISuppressor result_boolean =
5441      new NISuppressor(0, RangeInt.BooleanVal.class);
5442  private static NISuppressor arg1_boolean =
5443      new NISuppressor(2, RangeInt.BooleanVal.class);
5444  private static NISuppressor arg2_boolean =
5445      new NISuppressor(1, RangeInt.BooleanVal.class);
5446
5447  private static NISuppressor result_even =
5448      new NISuppressor(0, RangeInt.Even.class);
5449  private static NISuppressor arg1_even =
5450      new NISuppressor(2, RangeInt.Even.class);
5451  private static NISuppressor arg2_even =
5452      new NISuppressor(1, RangeInt.Even.class);
5453
5454  private static NISuppressor result_power2 =
5455      new NISuppressor(0, RangeInt.PowerOfTwo.class);
5456  private static NISuppressor arg1_power2 =
5457      new NISuppressor(2, RangeInt.PowerOfTwo.class);
5458  private static NISuppressor arg2_power2 =
5459      new NISuppressor(1, RangeInt.PowerOfTwo.class);
5460
5461  private static NISuppressor result_and0_arg1 =
5462      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
5463  private static NISuppressor result_and0_arg2 =
5464      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
5465  private static NISuppressor arg1_and0_arg2 =
5466      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
5467
5468  // The arguments to bitwise subset are backwards from what one
5469  // might expect.  The second argument is a subset of the first
5470  // argument
5471  private static NISuppressor arg1_bw_subset_arg2 =
5472      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
5473  private static NISuppressor arg2_bw_subset_arg1 =
5474      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
5475
5476  private static NISuppressor result_shift0_arg1 =
5477      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
5478  private static NISuppressor result_shift0_arg2 =
5479      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
5480  private static NISuppressor arg1_shift0_arg2 =
5481      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
5482
5483  private static NISuppressor arg2_divides_arg1 =
5484      new NISuppressor(2, 1, NumericInt.Divides.class);
5485  private static NISuppressor arg1_divides_arg2 =
5486      new NISuppressor(1, 2, NumericInt.Divides.class);
5487
5488  private static NISuppressor arg2_valid_shift =
5489      new NISuppressor(1, RangeInt.Bound0_63.class);
5490
5491    // Note that any suppression that doesn't limit y to valid exponents
5492    // (>= 0), must check for valid exponents as well (so that the invariant
5493    // is correctly destroyed on invalid exponents)
5494    //
5495    // Note also that pow(0,0) == 1 and pow(0,x), where (x > 0), == 0
5496    // Another interesting artificat of pow is that for any even base, any
5497    // exponent >= 64 will yield a result of 0.  For example, pow(10,256) == 0
5498    // (at least for integers)
5499
5500    private static NISuppressionSet suppressions =
5501      new NISuppressionSet(
5502          new NISuppression[] {
5503
5504            // (r == 1) && (y == 0) ==> r = pow (z, y)
5505            new NISuppression(result_eq_1, arg2_eq_0, suppressee),
5506
5507            // (r == 1) && (z == 1) && (y >= 0)   ==> r = pow (z, y)
5508            new NISuppression(result_eq_1, arg1_eq_1, arg2_ge_0, suppressee),
5509
5510            // (r == 0) && (z == 0) && (y > 0)
5511            new NISuppression(result_eq_0, arg1_eq_0, arg2_ne_0, arg2_ge_0,
5512                              suppressee),
5513
5514            // (r == z) && (y == 1)    ==> r = pow (z, y)
5515            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
5516
5517            // (r == 0) && (z even) && (y >= 64)
5518            // with each multiply there is one more zero in the result and since
5519            // a long has 64 bits in it, it becomes zero at that point
5520            new NISuppression(result_eq_0, arg1_even, arg2_ge_64, suppressee),
5521
5522            // (r == 1) && (z boolean) && (z==0 <==> y==0) && (y >= 0)
5523            // 1 = pow (0, y) true iff (y == 0)
5524            // 1 = pow (1, y) true when y valid exponent
5525            new NISuppression(arg1_track0_arg2, arg2_ge_0, arg1_boolean,
5526                               result_eq_1, suppressee),
5527
5528            // (r == z) && (r boolean) && (y > 0)
5529            // 0 = pow (0, y) true when y != 0
5530            // 1 = pow (1, y) true when y valid exponent
5531            new NISuppression(result_eq_arg1, result_boolean, arg2_ne_0,
5532                               arg2_ge_0, suppressee),
5533
5534          });
5535
5536  // Create a suppression factory for functionBinary
5537
5538}
5539
5540/**
5541 * Represents the invariant {@code y = Power(z, x)} over three long
5542 * scalars. 
5543 */
5544public static class PowerLong_yzx extends FunctionBinary {
5545  // We are Serializable, so we specify a version to allow changes to
5546  // method signatures without breaking serialization.  If you add or
5547  // remove fields, you should change this number to the current date.
5548  static final long serialVersionUID = 20031030L;
5549
5550  private static @Prototype PowerLong_yzx proto = new @Prototype PowerLong_yzx ();
5551
5552  /** Returns the prototype invariant for PowerLong_yzx */
5553  public static @Prototype PowerLong_yzx get_proto() {
5554    return proto;
5555  }
5556
5557  /** instantiate an invariant on the specified slice */
5558  @Override
5559  protected PowerLong_yzx instantiate_dyn(@Prototype PowerLong_yzx this, PptSlice slice) {
5560    return new PowerLong_yzx (slice);
5561  }
5562
5563  private PowerLong_yzx (PptSlice slice) {
5564    super(slice);
5565  }
5566
5567  public @Prototype PowerLong_yzx () {
5568    super();
5569  }
5570
5571  private static String[] method_name = new String[] {"java.lang.Math.pow(", ", ", ")"};
5572
5573  @Override
5574  public String[] get_method_name(@GuardSatisfied PowerLong_yzx this) {
5575    return method_name;
5576  }
5577
5578  private static int function_id = -1;
5579
5580  @Override
5581  public int get_function_id() {
5582    return function_id;
5583  }
5584
5585  @Override
5586  public void set_function_id(int function_id) {
5587    assert PowerLong_yzx.function_id == -1;
5588    PowerLong_yzx.function_id = function_id;
5589  }
5590
5591  private static int var_order = 5;
5592
5593  @Override
5594  public int get_var_order(@GuardSatisfied PowerLong_yzx this) {
5595    return var_order;
5596  }
5597
5598  @Pure
5599  @Override
5600  public boolean is_symmetric() {
5601
5602      return false;
5603  }
5604
5605  @Override
5606
5607  public long func(long z, long x) {
5608
5609    return MathPlume.pow(z, x);
5610  }
5611
5612  @Override
5613  public InvariantStatus check_modified(long x, long y,
5614                                      long z, int count) {
5615    return check_ordered(y, z, x, count);
5616  }
5617
5618  @Override
5619  public InvariantStatus add_modified(long x, long y,
5620                                      long z, int count) {
5621    if (Debug.logDetail()) {
5622      log("result=%s, arg1=%s, arg2=%s", y, z, x);
5623    }
5624    return add_ordered(y, z, x, count);
5625  }
5626
5627  @Pure
5628  @Override
5629  public boolean isPower() {
5630    return true;
5631  }
5632
5633  @Pure
5634  @Override
5635  public boolean isExact() {
5636    return true;
5637  }
5638
5639  /** Returns a list of non-instantiating suppressions for this invariant. */
5640  @Pure
5641  @Override
5642  public @Nullable NISuppressionSet get_ni_suppressions() {
5643    if (NIS.dkconfig_enabled && dkconfig_enabled) {
5644      return suppressions;
5645    } else {
5646      return null;
5647    }
5648  }
5649
5650  /** definition of this invariant (the suppressee) */
5651  private static NISuppressee suppressee = new NISuppressee(PowerLong_yzx.class, 3);
5652
5653  // suppressor definitions (used below)
5654  private static NISuppressor result_eq_arg1 =
5655      new NISuppressor(1, 2, IntEqual.class);
5656  private static NISuppressor result_eq_arg2 =
5657      new NISuppressor(1, 0, IntEqual.class);
5658  private static NISuppressor arg1_eq_arg2 =
5659      new NISuppressor(2, 0, IntEqual.class);
5660
5661  private static NISuppressor result_lt_arg1 =
5662      new NISuppressor(1, 2, IntLessThan.class);
5663  private static NISuppressor result_lt_arg2 =
5664      new NISuppressor(1, 0, IntLessThan.class);
5665  private static NISuppressor arg1_lt_arg2 =
5666      new NISuppressor(2, 0, IntLessThan.class);
5667  private static NISuppressor arg2_lt_arg1 =
5668      new NISuppressor(0, 2, IntLessThan.class);
5669
5670  private static NISuppressor result_le_arg1 =
5671      new NISuppressor(1, 2, IntLessEqual.class);
5672  private static NISuppressor result_le_arg2 =
5673      new NISuppressor(1, 0, IntLessEqual.class);
5674  private static NISuppressor arg1_le_arg2 =
5675      new NISuppressor(2, 0, IntLessEqual.class);
5676  private static NISuppressor arg2_le_arg1 =
5677      new NISuppressor(0, 2, IntLessEqual.class);
5678
5679  private static NISuppressor result_track0_arg1 =
5680      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
5681  private static NISuppressor result_track0_arg2 =
5682      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
5683  private static NISuppressor arg1_track0_arg2 =
5684      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
5685  private static NISuppressor arg1_track0_result =
5686      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
5687  private static NISuppressor arg2_track0_result =
5688      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
5689  private static NISuppressor arg2_track0_arg1 =
5690      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
5691
5692  private static NISuppressor result_eq_1 =
5693      new NISuppressor(1, RangeInt.EqualOne.class);
5694  private static NISuppressor arg1_eq_1 =
5695      new NISuppressor(2, RangeInt.EqualOne.class);
5696  private static NISuppressor arg2_eq_1 =
5697      new NISuppressor(0, RangeInt.EqualOne.class);
5698
5699  private static NISuppressor result_eq_0 =
5700      new NISuppressor(1, RangeInt.EqualZero.class);
5701  private static NISuppressor arg1_eq_0 =
5702      new NISuppressor(2, RangeInt.EqualZero.class);
5703  private static NISuppressor arg2_eq_0 =
5704      new NISuppressor(0, RangeInt.EqualZero.class);
5705
5706  private static NISuppressor result_ne_0 =
5707      new NISuppressor(1, NonZero.class);
5708  private static NISuppressor arg1_ne_0 =
5709      new NISuppressor(2, NonZero.class);
5710  private static NISuppressor arg2_ne_0 =
5711      new NISuppressor(0, NonZero.class);
5712
5713  private static NISuppressor result_ge_0 =
5714      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
5715  private static NISuppressor arg1_ge_0 =
5716      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
5717  private static NISuppressor arg2_ge_0 =
5718      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
5719
5720  private static NISuppressor result_ge_64 =
5721      new NISuppressor(1, RangeInt.GreaterEqual64.class);
5722  private static NISuppressor arg1_ge_64 =
5723      new NISuppressor(2, RangeInt.GreaterEqual64.class);
5724  private static NISuppressor arg2_ge_64 =
5725      new NISuppressor(0, RangeInt.GreaterEqual64.class);
5726
5727  private static NISuppressor result_boolean =
5728      new NISuppressor(1, RangeInt.BooleanVal.class);
5729  private static NISuppressor arg1_boolean =
5730      new NISuppressor(2, RangeInt.BooleanVal.class);
5731  private static NISuppressor arg2_boolean =
5732      new NISuppressor(0, RangeInt.BooleanVal.class);
5733
5734  private static NISuppressor result_even =
5735      new NISuppressor(1, RangeInt.Even.class);
5736  private static NISuppressor arg1_even =
5737      new NISuppressor(2, RangeInt.Even.class);
5738  private static NISuppressor arg2_even =
5739      new NISuppressor(0, RangeInt.Even.class);
5740
5741  private static NISuppressor result_power2 =
5742      new NISuppressor(1, RangeInt.PowerOfTwo.class);
5743  private static NISuppressor arg1_power2 =
5744      new NISuppressor(2, RangeInt.PowerOfTwo.class);
5745  private static NISuppressor arg2_power2 =
5746      new NISuppressor(0, RangeInt.PowerOfTwo.class);
5747
5748  private static NISuppressor result_and0_arg1 =
5749      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
5750  private static NISuppressor result_and0_arg2 =
5751      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
5752  private static NISuppressor arg1_and0_arg2 =
5753      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
5754
5755  // The arguments to bitwise subset are backwards from what one
5756  // might expect.  The second argument is a subset of the first
5757  // argument
5758  private static NISuppressor arg1_bw_subset_arg2 =
5759      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
5760  private static NISuppressor arg2_bw_subset_arg1 =
5761      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
5762
5763  private static NISuppressor result_shift0_arg1 =
5764      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
5765  private static NISuppressor result_shift0_arg2 =
5766      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
5767  private static NISuppressor arg1_shift0_arg2 =
5768      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
5769
5770  private static NISuppressor arg2_divides_arg1 =
5771      new NISuppressor(2, 0, NumericInt.Divides.class);
5772  private static NISuppressor arg1_divides_arg2 =
5773      new NISuppressor(0, 2, NumericInt.Divides.class);
5774
5775  private static NISuppressor arg2_valid_shift =
5776      new NISuppressor(0, RangeInt.Bound0_63.class);
5777
5778    // Note that any suppression that doesn't limit x to valid exponents
5779    // (>= 0), must check for valid exponents as well (so that the invariant
5780    // is correctly destroyed on invalid exponents)
5781    //
5782    // Note also that pow(0,0) == 1 and pow(0,x), where (x > 0), == 0
5783    // Another interesting artificat of pow is that for any even base, any
5784    // exponent >= 64 will yield a result of 0.  For example, pow(10,256) == 0
5785    // (at least for integers)
5786
5787    private static NISuppressionSet suppressions =
5788      new NISuppressionSet(
5789          new NISuppression[] {
5790
5791            // (r == 1) && (x == 0) ==> r = pow (z, x)
5792            new NISuppression(result_eq_1, arg2_eq_0, suppressee),
5793
5794            // (r == 1) && (z == 1) && (x >= 0)   ==> r = pow (z, x)
5795            new NISuppression(result_eq_1, arg1_eq_1, arg2_ge_0, suppressee),
5796
5797            // (r == 0) && (z == 0) && (x > 0)
5798            new NISuppression(result_eq_0, arg1_eq_0, arg2_ne_0, arg2_ge_0,
5799                              suppressee),
5800
5801            // (r == z) && (x == 1)    ==> r = pow (z, x)
5802            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
5803
5804            // (r == 0) && (z even) && (x >= 64)
5805            // with each multiply there is one more zero in the result and since
5806            // a long has 64 bits in it, it becomes zero at that point
5807            new NISuppression(result_eq_0, arg1_even, arg2_ge_64, suppressee),
5808
5809            // (r == 1) && (z boolean) && (z==0 <==> x==0) && (x >= 0)
5810            // 1 = pow (0, x) true iff (x == 0)
5811            // 1 = pow (1, x) true when x valid exponent
5812            new NISuppression(arg1_track0_arg2, arg2_ge_0, arg1_boolean,
5813                               result_eq_1, suppressee),
5814
5815            // (r == z) && (r boolean) && (x > 0)
5816            // 0 = pow (0, x) true when x != 0
5817            // 1 = pow (1, x) true when x valid exponent
5818            new NISuppression(result_eq_arg1, result_boolean, arg2_ne_0,
5819                               arg2_ge_0, suppressee),
5820
5821          });
5822
5823  // Create a suppression factory for functionBinary
5824
5825}
5826
5827/**
5828 * Represents the invariant {@code z = Power(y, x)} over three long
5829 * scalars. 
5830 */
5831public static class PowerLong_zyx extends FunctionBinary {
5832  // We are Serializable, so we specify a version to allow changes to
5833  // method signatures without breaking serialization.  If you add or
5834  // remove fields, you should change this number to the current date.
5835  static final long serialVersionUID = 20031030L;
5836
5837  private static @Prototype PowerLong_zyx proto = new @Prototype PowerLong_zyx ();
5838
5839  /** Returns the prototype invariant for PowerLong_zyx */
5840  public static @Prototype PowerLong_zyx get_proto() {
5841    return proto;
5842  }
5843
5844  /** instantiate an invariant on the specified slice */
5845  @Override
5846  protected PowerLong_zyx instantiate_dyn(@Prototype PowerLong_zyx this, PptSlice slice) {
5847    return new PowerLong_zyx (slice);
5848  }
5849
5850  private PowerLong_zyx (PptSlice slice) {
5851    super(slice);
5852  }
5853
5854  public @Prototype PowerLong_zyx () {
5855    super();
5856  }
5857
5858  private static String[] method_name = new String[] {"java.lang.Math.pow(", ", ", ")"};
5859
5860  @Override
5861  public String[] get_method_name(@GuardSatisfied PowerLong_zyx this) {
5862    return method_name;
5863  }
5864
5865  private static int function_id = -1;
5866
5867  @Override
5868  public int get_function_id() {
5869    return function_id;
5870  }
5871
5872  @Override
5873  public void set_function_id(int function_id) {
5874    assert PowerLong_zyx.function_id == -1;
5875    PowerLong_zyx.function_id = function_id;
5876  }
5877
5878  private static int var_order = 6;
5879
5880  @Override
5881  public int get_var_order(@GuardSatisfied PowerLong_zyx this) {
5882    return var_order;
5883  }
5884
5885  @Pure
5886  @Override
5887  public boolean is_symmetric() {
5888
5889      return false;
5890  }
5891
5892  @Override
5893
5894  public long func(long y, long x) {
5895
5896    return MathPlume.pow(y, x);
5897  }
5898
5899  @Override
5900  public InvariantStatus check_modified(long x, long y,
5901                                      long z, int count) {
5902    return check_ordered(z, y, x, count);
5903  }
5904
5905  @Override
5906  public InvariantStatus add_modified(long x, long y,
5907                                      long z, int count) {
5908    if (Debug.logDetail()) {
5909      log("result=%s, arg1=%s, arg2=%s", z, y, x);
5910    }
5911    return add_ordered(z, y, x, count);
5912  }
5913
5914  @Pure
5915  @Override
5916  public boolean isPower() {
5917    return true;
5918  }
5919
5920  @Pure
5921  @Override
5922  public boolean isExact() {
5923    return true;
5924  }
5925
5926  /** Returns a list of non-instantiating suppressions for this invariant. */
5927  @Pure
5928  @Override
5929  public @Nullable NISuppressionSet get_ni_suppressions() {
5930    if (NIS.dkconfig_enabled && dkconfig_enabled) {
5931      return suppressions;
5932    } else {
5933      return null;
5934    }
5935  }
5936
5937  /** definition of this invariant (the suppressee) */
5938  private static NISuppressee suppressee = new NISuppressee(PowerLong_zyx.class, 3);
5939
5940  // suppressor definitions (used below)
5941  private static NISuppressor result_eq_arg1 =
5942      new NISuppressor(2, 1, IntEqual.class);
5943  private static NISuppressor result_eq_arg2 =
5944      new NISuppressor(2, 0, IntEqual.class);
5945  private static NISuppressor arg1_eq_arg2 =
5946      new NISuppressor(1, 0, IntEqual.class);
5947
5948  private static NISuppressor result_lt_arg1 =
5949      new NISuppressor(2, 1, IntLessThan.class);
5950  private static NISuppressor result_lt_arg2 =
5951      new NISuppressor(2, 0, IntLessThan.class);
5952  private static NISuppressor arg1_lt_arg2 =
5953      new NISuppressor(1, 0, IntLessThan.class);
5954  private static NISuppressor arg2_lt_arg1 =
5955      new NISuppressor(0, 1, IntLessThan.class);
5956
5957  private static NISuppressor result_le_arg1 =
5958      new NISuppressor(2, 1, IntLessEqual.class);
5959  private static NISuppressor result_le_arg2 =
5960      new NISuppressor(2, 0, IntLessEqual.class);
5961  private static NISuppressor arg1_le_arg2 =
5962      new NISuppressor(1, 0, IntLessEqual.class);
5963  private static NISuppressor arg2_le_arg1 =
5964      new NISuppressor(0, 1, IntLessEqual.class);
5965
5966  private static NISuppressor result_track0_arg1 =
5967      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
5968  private static NISuppressor result_track0_arg2 =
5969      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
5970  private static NISuppressor arg1_track0_arg2 =
5971      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
5972  private static NISuppressor arg1_track0_result =
5973      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
5974  private static NISuppressor arg2_track0_result =
5975      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
5976  private static NISuppressor arg2_track0_arg1 =
5977      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
5978
5979  private static NISuppressor result_eq_1 =
5980      new NISuppressor(2, RangeInt.EqualOne.class);
5981  private static NISuppressor arg1_eq_1 =
5982      new NISuppressor(1, RangeInt.EqualOne.class);
5983  private static NISuppressor arg2_eq_1 =
5984      new NISuppressor(0, RangeInt.EqualOne.class);
5985
5986  private static NISuppressor result_eq_0 =
5987      new NISuppressor(2, RangeInt.EqualZero.class);
5988  private static NISuppressor arg1_eq_0 =
5989      new NISuppressor(1, RangeInt.EqualZero.class);
5990  private static NISuppressor arg2_eq_0 =
5991      new NISuppressor(0, RangeInt.EqualZero.class);
5992
5993  private static NISuppressor result_ne_0 =
5994      new NISuppressor(2, NonZero.class);
5995  private static NISuppressor arg1_ne_0 =
5996      new NISuppressor(1, NonZero.class);
5997  private static NISuppressor arg2_ne_0 =
5998      new NISuppressor(0, NonZero.class);
5999
6000  private static NISuppressor result_ge_0 =
6001      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
6002  private static NISuppressor arg1_ge_0 =
6003      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
6004  private static NISuppressor arg2_ge_0 =
6005      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
6006
6007  private static NISuppressor result_ge_64 =
6008      new NISuppressor(2, RangeInt.GreaterEqual64.class);
6009  private static NISuppressor arg1_ge_64 =
6010      new NISuppressor(1, RangeInt.GreaterEqual64.class);
6011  private static NISuppressor arg2_ge_64 =
6012      new NISuppressor(0, RangeInt.GreaterEqual64.class);
6013
6014  private static NISuppressor result_boolean =
6015      new NISuppressor(2, RangeInt.BooleanVal.class);
6016  private static NISuppressor arg1_boolean =
6017      new NISuppressor(1, RangeInt.BooleanVal.class);
6018  private static NISuppressor arg2_boolean =
6019      new NISuppressor(0, RangeInt.BooleanVal.class);
6020
6021  private static NISuppressor result_even =
6022      new NISuppressor(2, RangeInt.Even.class);
6023  private static NISuppressor arg1_even =
6024      new NISuppressor(1, RangeInt.Even.class);
6025  private static NISuppressor arg2_even =
6026      new NISuppressor(0, RangeInt.Even.class);
6027
6028  private static NISuppressor result_power2 =
6029      new NISuppressor(2, RangeInt.PowerOfTwo.class);
6030  private static NISuppressor arg1_power2 =
6031      new NISuppressor(1, RangeInt.PowerOfTwo.class);
6032  private static NISuppressor arg2_power2 =
6033      new NISuppressor(0, RangeInt.PowerOfTwo.class);
6034
6035  private static NISuppressor result_and0_arg1 =
6036      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
6037  private static NISuppressor result_and0_arg2 =
6038      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
6039  private static NISuppressor arg1_and0_arg2 =
6040      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
6041
6042  // The arguments to bitwise subset are backwards from what one
6043  // might expect.  The second argument is a subset of the first
6044  // argument
6045  private static NISuppressor arg1_bw_subset_arg2 =
6046      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
6047  private static NISuppressor arg2_bw_subset_arg1 =
6048      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
6049
6050  private static NISuppressor result_shift0_arg1 =
6051      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
6052  private static NISuppressor result_shift0_arg2 =
6053      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
6054  private static NISuppressor arg1_shift0_arg2 =
6055      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
6056
6057  private static NISuppressor arg2_divides_arg1 =
6058      new NISuppressor(1, 0, NumericInt.Divides.class);
6059  private static NISuppressor arg1_divides_arg2 =
6060      new NISuppressor(0, 1, NumericInt.Divides.class);
6061
6062  private static NISuppressor arg2_valid_shift =
6063      new NISuppressor(0, RangeInt.Bound0_63.class);
6064
6065    // Note that any suppression that doesn't limit x to valid exponents
6066    // (>= 0), must check for valid exponents as well (so that the invariant
6067    // is correctly destroyed on invalid exponents)
6068    //
6069    // Note also that pow(0,0) == 1 and pow(0,x), where (x > 0), == 0
6070    // Another interesting artificat of pow is that for any even base, any
6071    // exponent >= 64 will yield a result of 0.  For example, pow(10,256) == 0
6072    // (at least for integers)
6073
6074    private static NISuppressionSet suppressions =
6075      new NISuppressionSet(
6076          new NISuppression[] {
6077
6078            // (r == 1) && (x == 0) ==> r = pow (y, x)
6079            new NISuppression(result_eq_1, arg2_eq_0, suppressee),
6080
6081            // (r == 1) && (y == 1) && (x >= 0)   ==> r = pow (y, x)
6082            new NISuppression(result_eq_1, arg1_eq_1, arg2_ge_0, suppressee),
6083
6084            // (r == 0) && (y == 0) && (x > 0)
6085            new NISuppression(result_eq_0, arg1_eq_0, arg2_ne_0, arg2_ge_0,
6086                              suppressee),
6087
6088            // (r == y) && (x == 1)    ==> r = pow (y, x)
6089            new NISuppression(result_eq_arg1, arg2_eq_1, suppressee),
6090
6091            // (r == 0) && (y even) && (x >= 64)
6092            // with each multiply there is one more zero in the result and since
6093            // a long has 64 bits in it, it becomes zero at that point
6094            new NISuppression(result_eq_0, arg1_even, arg2_ge_64, suppressee),
6095
6096            // (r == 1) && (y boolean) && (y==0 <==> x==0) && (x >= 0)
6097            // 1 = pow (0, x) true iff (x == 0)
6098            // 1 = pow (1, x) true when x valid exponent
6099            new NISuppression(arg1_track0_arg2, arg2_ge_0, arg1_boolean,
6100                               result_eq_1, suppressee),
6101
6102            // (r == y) && (r boolean) && (x > 0)
6103            // 0 = pow (0, x) true when x != 0
6104            // 1 = pow (1, x) true when x valid exponent
6105            new NISuppression(result_eq_arg1, result_boolean, arg2_ne_0,
6106                               arg2_ge_0, suppressee),
6107
6108          });
6109
6110  // Create a suppression factory for functionBinary
6111
6112}
6113
6114  // #define EQUALITY_SUPPRESS 1
6115
6116  // default is that it is not this function, overriden in the subclass
6117  @Pure
6118  public boolean isBitwiseAnd() {
6119    return false;
6120  }
6121
6122/**
6123 * Represents the invariant {@code x = BitwiseAnd(y, z)} over three long
6124 * scalars. 
6125 */
6126public static class BitwiseAndLong_xyz extends FunctionBinary {
6127  // We are Serializable, so we specify a version to allow changes to
6128  // method signatures without breaking serialization.  If you add or
6129  // remove fields, you should change this number to the current date.
6130  static final long serialVersionUID = 20031030L;
6131
6132  private static @Prototype BitwiseAndLong_xyz proto = new @Prototype BitwiseAndLong_xyz ();
6133
6134  /** Returns the prototype invariant for BitwiseAndLong_xyz */
6135  public static @Prototype BitwiseAndLong_xyz get_proto() {
6136    return proto;
6137  }
6138
6139  /** instantiate an invariant on the specified slice */
6140  @Override
6141  protected BitwiseAndLong_xyz instantiate_dyn(@Prototype BitwiseAndLong_xyz this, PptSlice slice) {
6142    return new BitwiseAndLong_xyz (slice);
6143  }
6144
6145  private BitwiseAndLong_xyz (PptSlice slice) {
6146    super(slice);
6147  }
6148
6149  public @Prototype BitwiseAndLong_xyz () {
6150    super();
6151  }
6152
6153  private static String[] method_name = new String[] {"", " & ", ""};
6154
6155  @Override
6156  public String[] get_method_name(@GuardSatisfied BitwiseAndLong_xyz this) {
6157    return method_name;
6158  }
6159
6160  private static int function_id = -1;
6161
6162  @Override
6163  public int get_function_id() {
6164    return function_id;
6165  }
6166
6167  @Override
6168  public void set_function_id(int function_id) {
6169    assert BitwiseAndLong_xyz.function_id == -1;
6170    BitwiseAndLong_xyz.function_id = function_id;
6171  }
6172
6173  private static int var_order = 1;
6174
6175  @Override
6176  public int get_var_order(@GuardSatisfied BitwiseAndLong_xyz this) {
6177    return var_order;
6178  }
6179
6180  @Pure
6181  @Override
6182  public boolean is_symmetric() {
6183
6184      return true;
6185  }
6186
6187  @Override
6188
6189  public long func(long y, long z) {
6190
6191    return (y & z);
6192  }
6193
6194  @Override
6195  public InvariantStatus check_modified(long x, long y,
6196                                      long z, int count) {
6197    return check_ordered(x, y, z, count);
6198  }
6199
6200  @Override
6201  public InvariantStatus add_modified(long x, long y,
6202                                      long z, int count) {
6203    if (Debug.logDetail()) {
6204      log("result=%s, arg1=%s, arg2=%s", x, y, z);
6205    }
6206    return add_ordered(x, y, z, count);
6207  }
6208
6209  @Pure
6210  @Override
6211  public boolean isBitwiseAnd() {
6212    return true;
6213  }
6214
6215  @Pure
6216  @Override
6217  public boolean isExact() {
6218    return true;
6219  }
6220
6221  /** Returns a list of non-instantiating suppressions for this invariant. */
6222  @Pure
6223  @Override
6224  public @Nullable NISuppressionSet get_ni_suppressions() {
6225    if (NIS.dkconfig_enabled && dkconfig_enabled) {
6226      return suppressions;
6227    } else {
6228      return null;
6229    }
6230  }
6231
6232  /** definition of this invariant (the suppressee) */
6233  private static NISuppressee suppressee = new NISuppressee(BitwiseAndLong_xyz.class, 3);
6234
6235  // suppressor definitions (used below)
6236  private static NISuppressor result_eq_arg1 =
6237      new NISuppressor(0, 1, IntEqual.class);
6238  private static NISuppressor result_eq_arg2 =
6239      new NISuppressor(0, 2, IntEqual.class);
6240  private static NISuppressor arg1_eq_arg2 =
6241      new NISuppressor(1, 2, IntEqual.class);
6242
6243  private static NISuppressor result_lt_arg1 =
6244      new NISuppressor(0, 1, IntLessThan.class);
6245  private static NISuppressor result_lt_arg2 =
6246      new NISuppressor(0, 2, IntLessThan.class);
6247  private static NISuppressor arg1_lt_arg2 =
6248      new NISuppressor(1, 2, IntLessThan.class);
6249  private static NISuppressor arg2_lt_arg1 =
6250      new NISuppressor(2, 1, IntLessThan.class);
6251
6252  private static NISuppressor result_le_arg1 =
6253      new NISuppressor(0, 1, IntLessEqual.class);
6254  private static NISuppressor result_le_arg2 =
6255      new NISuppressor(0, 2, IntLessEqual.class);
6256  private static NISuppressor arg1_le_arg2 =
6257      new NISuppressor(1, 2, IntLessEqual.class);
6258  private static NISuppressor arg2_le_arg1 =
6259      new NISuppressor(2, 1, IntLessEqual.class);
6260
6261  private static NISuppressor result_track0_arg1 =
6262      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
6263  private static NISuppressor result_track0_arg2 =
6264      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
6265  private static NISuppressor arg1_track0_arg2 =
6266      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
6267  private static NISuppressor arg1_track0_result =
6268      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
6269  private static NISuppressor arg2_track0_result =
6270      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
6271  private static NISuppressor arg2_track0_arg1 =
6272      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
6273
6274  private static NISuppressor result_eq_1 =
6275      new NISuppressor(0, RangeInt.EqualOne.class);
6276  private static NISuppressor arg1_eq_1 =
6277      new NISuppressor(1, RangeInt.EqualOne.class);
6278  private static NISuppressor arg2_eq_1 =
6279      new NISuppressor(2, RangeInt.EqualOne.class);
6280
6281  private static NISuppressor result_eq_0 =
6282      new NISuppressor(0, RangeInt.EqualZero.class);
6283  private static NISuppressor arg1_eq_0 =
6284      new NISuppressor(1, RangeInt.EqualZero.class);
6285  private static NISuppressor arg2_eq_0 =
6286      new NISuppressor(2, RangeInt.EqualZero.class);
6287
6288  private static NISuppressor result_ne_0 =
6289      new NISuppressor(0, NonZero.class);
6290  private static NISuppressor arg1_ne_0 =
6291      new NISuppressor(1, NonZero.class);
6292  private static NISuppressor arg2_ne_0 =
6293      new NISuppressor(2, NonZero.class);
6294
6295  private static NISuppressor result_ge_0 =
6296      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
6297  private static NISuppressor arg1_ge_0 =
6298      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
6299  private static NISuppressor arg2_ge_0 =
6300      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
6301
6302  private static NISuppressor result_ge_64 =
6303      new NISuppressor(0, RangeInt.GreaterEqual64.class);
6304  private static NISuppressor arg1_ge_64 =
6305      new NISuppressor(1, RangeInt.GreaterEqual64.class);
6306  private static NISuppressor arg2_ge_64 =
6307      new NISuppressor(2, RangeInt.GreaterEqual64.class);
6308
6309  private static NISuppressor result_boolean =
6310      new NISuppressor(0, RangeInt.BooleanVal.class);
6311  private static NISuppressor arg1_boolean =
6312      new NISuppressor(1, RangeInt.BooleanVal.class);
6313  private static NISuppressor arg2_boolean =
6314      new NISuppressor(2, RangeInt.BooleanVal.class);
6315
6316  private static NISuppressor result_even =
6317      new NISuppressor(0, RangeInt.Even.class);
6318  private static NISuppressor arg1_even =
6319      new NISuppressor(1, RangeInt.Even.class);
6320  private static NISuppressor arg2_even =
6321      new NISuppressor(2, RangeInt.Even.class);
6322
6323  private static NISuppressor result_power2 =
6324      new NISuppressor(0, RangeInt.PowerOfTwo.class);
6325  private static NISuppressor arg1_power2 =
6326      new NISuppressor(1, RangeInt.PowerOfTwo.class);
6327  private static NISuppressor arg2_power2 =
6328      new NISuppressor(2, RangeInt.PowerOfTwo.class);
6329
6330  private static NISuppressor result_and0_arg1 =
6331      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
6332  private static NISuppressor result_and0_arg2 =
6333      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
6334  private static NISuppressor arg1_and0_arg2 =
6335      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
6336
6337  // The arguments to bitwise subset are backwards from what one
6338  // might expect.  The second argument is a subset of the first
6339  // argument
6340  private static NISuppressor arg1_bw_subset_arg2 =
6341      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
6342  private static NISuppressor arg2_bw_subset_arg1 =
6343      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
6344
6345  private static NISuppressor result_shift0_arg1 =
6346      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
6347  private static NISuppressor result_shift0_arg2 =
6348      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
6349  private static NISuppressor arg1_shift0_arg2 =
6350      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
6351
6352  private static NISuppressor arg2_divides_arg1 =
6353      new NISuppressor(1, 2, NumericInt.Divides.class);
6354  private static NISuppressor arg1_divides_arg2 =
6355      new NISuppressor(2, 1, NumericInt.Divides.class);
6356
6357  private static NISuppressor arg2_valid_shift =
6358      new NISuppressor(2, RangeInt.Bound0_63.class);
6359
6360    private static NISuppressionSet suppressions =
6361        new NISuppressionSet(
6362          new NISuppression[] {
6363
6364            // (r == y) && (y == z) && (r == z) ==> r = y &  z
6365            new NISuppression(result_eq_arg1, arg1_eq_arg2, result_eq_arg2,
6366                               suppressee),
6367
6368            // (r == y) && (y bitwise subset z)
6369            new NISuppression(result_eq_arg1, arg1_bw_subset_arg2, suppressee),
6370
6371            // (r == z) && (z bitwise subset y)
6372            new NISuppression(result_eq_arg2, arg2_bw_subset_arg1, suppressee),
6373
6374            // (r == 0) && (y & z == 0) ==> r = y & z
6375            new NISuppression(result_eq_0, arg1_and0_arg2, suppressee),
6376
6377            // All of these are subsummed by the prior one
6378            // (r == 0) && (y == 0) ==> r = y & z
6379            // new NISuppression (result_eq_0, arg1_eq_0, suppressee),
6380
6381            // (r == 0) && (z == 0) ==> r = y & z
6382            // new NISuppression (result_eq_0, arg2_eq_0, suppressee),
6383
6384            // (r == 0) && (y boolean) && (z is even)
6385            // new NISuppression (result_eq_0, arg1_boolean, arg2_even, suppressee),
6386
6387            // (r == 0) && (z boolean) && (y is even)
6388            // new NISuppression (result_eq_0, arg2_boolean, arg1_even, suppressee),
6389
6390            // (r == 0) && (z > y) && (z power2) && (y >= 0)
6391            // new NISuppression (result_eq_0, arg1_lt_arg2, arg2_power2, arg1_ge_0,
6392            //                   suppressee),
6393
6394            // (r == 0) && (y > z) && (y power2) && (z >= 0)
6395            // new NISuppression (result_eq_0, arg2_lt_arg1, arg1_power2, arg2_ge_0,
6396            //                   suppressee),
6397
6398            // (r == y) && (r boolean) && (z == 1)
6399            new NISuppression(result_eq_arg1, result_boolean, arg2_eq_1,
6400                               suppressee),
6401
6402            // (r == z) && (r boolean) && (y == 1)
6403            new NISuppression(result_eq_arg2, result_boolean, arg1_eq_1,
6404                               suppressee),
6405
6406          });
6407
6408  // Create a suppression factory for functionBinary
6409
6410}
6411
6412/**
6413 * Represents the invariant {@code y = BitwiseAnd(x, z)} over three long
6414 * scalars. 
6415 */
6416public static class BitwiseAndLong_yxz extends FunctionBinary {
6417  // We are Serializable, so we specify a version to allow changes to
6418  // method signatures without breaking serialization.  If you add or
6419  // remove fields, you should change this number to the current date.
6420  static final long serialVersionUID = 20031030L;
6421
6422  private static @Prototype BitwiseAndLong_yxz proto = new @Prototype BitwiseAndLong_yxz ();
6423
6424  /** Returns the prototype invariant for BitwiseAndLong_yxz */
6425  public static @Prototype BitwiseAndLong_yxz get_proto() {
6426    return proto;
6427  }
6428
6429  /** instantiate an invariant on the specified slice */
6430  @Override
6431  protected BitwiseAndLong_yxz instantiate_dyn(@Prototype BitwiseAndLong_yxz this, PptSlice slice) {
6432    return new BitwiseAndLong_yxz (slice);
6433  }
6434
6435  private BitwiseAndLong_yxz (PptSlice slice) {
6436    super(slice);
6437  }
6438
6439  public @Prototype BitwiseAndLong_yxz () {
6440    super();
6441  }
6442
6443  private static String[] method_name = new String[] {"", " & ", ""};
6444
6445  @Override
6446  public String[] get_method_name(@GuardSatisfied BitwiseAndLong_yxz this) {
6447    return method_name;
6448  }
6449
6450  private static int function_id = -1;
6451
6452  @Override
6453  public int get_function_id() {
6454    return function_id;
6455  }
6456
6457  @Override
6458  public void set_function_id(int function_id) {
6459    assert BitwiseAndLong_yxz.function_id == -1;
6460    BitwiseAndLong_yxz.function_id = function_id;
6461  }
6462
6463  private static int var_order = 2;
6464
6465  @Override
6466  public int get_var_order(@GuardSatisfied BitwiseAndLong_yxz this) {
6467    return var_order;
6468  }
6469
6470  @Pure
6471  @Override
6472  public boolean is_symmetric() {
6473
6474      return true;
6475  }
6476
6477  @Override
6478
6479  public long func(long x, long z) {
6480
6481    return (x & z);
6482  }
6483
6484  @Override
6485  public InvariantStatus check_modified(long x, long y,
6486                                      long z, int count) {
6487    return check_ordered(y, x, z, count);
6488  }
6489
6490  @Override
6491  public InvariantStatus add_modified(long x, long y,
6492                                      long z, int count) {
6493    if (Debug.logDetail()) {
6494      log("result=%s, arg1=%s, arg2=%s", y, x, z);
6495    }
6496    return add_ordered(y, x, z, count);
6497  }
6498
6499  @Pure
6500  @Override
6501  public boolean isBitwiseAnd() {
6502    return true;
6503  }
6504
6505  @Pure
6506  @Override
6507  public boolean isExact() {
6508    return true;
6509  }
6510
6511  /** Returns a list of non-instantiating suppressions for this invariant. */
6512  @Pure
6513  @Override
6514  public @Nullable NISuppressionSet get_ni_suppressions() {
6515    if (NIS.dkconfig_enabled && dkconfig_enabled) {
6516      return suppressions;
6517    } else {
6518      return null;
6519    }
6520  }
6521
6522  /** definition of this invariant (the suppressee) */
6523  private static NISuppressee suppressee = new NISuppressee(BitwiseAndLong_yxz.class, 3);
6524
6525  // suppressor definitions (used below)
6526  private static NISuppressor result_eq_arg1 =
6527      new NISuppressor(1, 0, IntEqual.class);
6528  private static NISuppressor result_eq_arg2 =
6529      new NISuppressor(1, 2, IntEqual.class);
6530  private static NISuppressor arg1_eq_arg2 =
6531      new NISuppressor(0, 2, IntEqual.class);
6532
6533  private static NISuppressor result_lt_arg1 =
6534      new NISuppressor(1, 0, IntLessThan.class);
6535  private static NISuppressor result_lt_arg2 =
6536      new NISuppressor(1, 2, IntLessThan.class);
6537  private static NISuppressor arg1_lt_arg2 =
6538      new NISuppressor(0, 2, IntLessThan.class);
6539  private static NISuppressor arg2_lt_arg1 =
6540      new NISuppressor(2, 0, IntLessThan.class);
6541
6542  private static NISuppressor result_le_arg1 =
6543      new NISuppressor(1, 0, IntLessEqual.class);
6544  private static NISuppressor result_le_arg2 =
6545      new NISuppressor(1, 2, IntLessEqual.class);
6546  private static NISuppressor arg1_le_arg2 =
6547      new NISuppressor(0, 2, IntLessEqual.class);
6548  private static NISuppressor arg2_le_arg1 =
6549      new NISuppressor(2, 0, IntLessEqual.class);
6550
6551  private static NISuppressor result_track0_arg1 =
6552      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
6553  private static NISuppressor result_track0_arg2 =
6554      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
6555  private static NISuppressor arg1_track0_arg2 =
6556      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
6557  private static NISuppressor arg1_track0_result =
6558      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
6559  private static NISuppressor arg2_track0_result =
6560      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
6561  private static NISuppressor arg2_track0_arg1 =
6562      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
6563
6564  private static NISuppressor result_eq_1 =
6565      new NISuppressor(1, RangeInt.EqualOne.class);
6566  private static NISuppressor arg1_eq_1 =
6567      new NISuppressor(0, RangeInt.EqualOne.class);
6568  private static NISuppressor arg2_eq_1 =
6569      new NISuppressor(2, RangeInt.EqualOne.class);
6570
6571  private static NISuppressor result_eq_0 =
6572      new NISuppressor(1, RangeInt.EqualZero.class);
6573  private static NISuppressor arg1_eq_0 =
6574      new NISuppressor(0, RangeInt.EqualZero.class);
6575  private static NISuppressor arg2_eq_0 =
6576      new NISuppressor(2, RangeInt.EqualZero.class);
6577
6578  private static NISuppressor result_ne_0 =
6579      new NISuppressor(1, NonZero.class);
6580  private static NISuppressor arg1_ne_0 =
6581      new NISuppressor(0, NonZero.class);
6582  private static NISuppressor arg2_ne_0 =
6583      new NISuppressor(2, NonZero.class);
6584
6585  private static NISuppressor result_ge_0 =
6586      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
6587  private static NISuppressor arg1_ge_0 =
6588      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
6589  private static NISuppressor arg2_ge_0 =
6590      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
6591
6592  private static NISuppressor result_ge_64 =
6593      new NISuppressor(1, RangeInt.GreaterEqual64.class);
6594  private static NISuppressor arg1_ge_64 =
6595      new NISuppressor(0, RangeInt.GreaterEqual64.class);
6596  private static NISuppressor arg2_ge_64 =
6597      new NISuppressor(2, RangeInt.GreaterEqual64.class);
6598
6599  private static NISuppressor result_boolean =
6600      new NISuppressor(1, RangeInt.BooleanVal.class);
6601  private static NISuppressor arg1_boolean =
6602      new NISuppressor(0, RangeInt.BooleanVal.class);
6603  private static NISuppressor arg2_boolean =
6604      new NISuppressor(2, RangeInt.BooleanVal.class);
6605
6606  private static NISuppressor result_even =
6607      new NISuppressor(1, RangeInt.Even.class);
6608  private static NISuppressor arg1_even =
6609      new NISuppressor(0, RangeInt.Even.class);
6610  private static NISuppressor arg2_even =
6611      new NISuppressor(2, RangeInt.Even.class);
6612
6613  private static NISuppressor result_power2 =
6614      new NISuppressor(1, RangeInt.PowerOfTwo.class);
6615  private static NISuppressor arg1_power2 =
6616      new NISuppressor(0, RangeInt.PowerOfTwo.class);
6617  private static NISuppressor arg2_power2 =
6618      new NISuppressor(2, RangeInt.PowerOfTwo.class);
6619
6620  private static NISuppressor result_and0_arg1 =
6621      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
6622  private static NISuppressor result_and0_arg2 =
6623      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
6624  private static NISuppressor arg1_and0_arg2 =
6625      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
6626
6627  // The arguments to bitwise subset are backwards from what one
6628  // might expect.  The second argument is a subset of the first
6629  // argument
6630  private static NISuppressor arg1_bw_subset_arg2 =
6631      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
6632  private static NISuppressor arg2_bw_subset_arg1 =
6633      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
6634
6635  private static NISuppressor result_shift0_arg1 =
6636      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
6637  private static NISuppressor result_shift0_arg2 =
6638      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
6639  private static NISuppressor arg1_shift0_arg2 =
6640      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
6641
6642  private static NISuppressor arg2_divides_arg1 =
6643      new NISuppressor(0, 2, NumericInt.Divides.class);
6644  private static NISuppressor arg1_divides_arg2 =
6645      new NISuppressor(2, 0, NumericInt.Divides.class);
6646
6647  private static NISuppressor arg2_valid_shift =
6648      new NISuppressor(2, RangeInt.Bound0_63.class);
6649
6650    private static NISuppressionSet suppressions =
6651        new NISuppressionSet(
6652          new NISuppression[] {
6653
6654            // (r == x) && (x == z) && (r == z) ==> r = x &  z
6655            new NISuppression(result_eq_arg1, arg1_eq_arg2, result_eq_arg2,
6656                               suppressee),
6657
6658            // (r == x) && (x bitwise subset z)
6659            new NISuppression(result_eq_arg1, arg1_bw_subset_arg2, suppressee),
6660
6661            // (r == z) && (z bitwise subset x)
6662            new NISuppression(result_eq_arg2, arg2_bw_subset_arg1, suppressee),
6663
6664            // (r == 0) && (x & z == 0) ==> r = x & z
6665            new NISuppression(result_eq_0, arg1_and0_arg2, suppressee),
6666
6667            // All of these are subsummed by the prior one
6668            // (r == 0) && (x == 0) ==> r = x & z
6669            // new NISuppression (result_eq_0, arg1_eq_0, suppressee),
6670
6671            // (r == 0) && (z == 0) ==> r = x & z
6672            // new NISuppression (result_eq_0, arg2_eq_0, suppressee),
6673
6674            // (r == 0) && (x boolean) && (z is even)
6675            // new NISuppression (result_eq_0, arg1_boolean, arg2_even, suppressee),
6676
6677            // (r == 0) && (z boolean) && (x is even)
6678            // new NISuppression (result_eq_0, arg2_boolean, arg1_even, suppressee),
6679
6680            // (r == 0) && (z > x) && (z power2) && (x >= 0)
6681            // new NISuppression (result_eq_0, arg1_lt_arg2, arg2_power2, arg1_ge_0,
6682            //                   suppressee),
6683
6684            // (r == 0) && (x > z) && (x power2) && (z >= 0)
6685            // new NISuppression (result_eq_0, arg2_lt_arg1, arg1_power2, arg2_ge_0,
6686            //                   suppressee),
6687
6688            // (r == x) && (r boolean) && (z == 1)
6689            new NISuppression(result_eq_arg1, result_boolean, arg2_eq_1,
6690                               suppressee),
6691
6692            // (r == z) && (r boolean) && (x == 1)
6693            new NISuppression(result_eq_arg2, result_boolean, arg1_eq_1,
6694                               suppressee),
6695
6696          });
6697
6698  // Create a suppression factory for functionBinary
6699
6700}
6701
6702/**
6703 * Represents the invariant {@code z = BitwiseAnd(x, y)} over three long
6704 * scalars. 
6705 */
6706public static class BitwiseAndLong_zxy extends FunctionBinary {
6707  // We are Serializable, so we specify a version to allow changes to
6708  // method signatures without breaking serialization.  If you add or
6709  // remove fields, you should change this number to the current date.
6710  static final long serialVersionUID = 20031030L;
6711
6712  private static @Prototype BitwiseAndLong_zxy proto = new @Prototype BitwiseAndLong_zxy ();
6713
6714  /** Returns the prototype invariant for BitwiseAndLong_zxy */
6715  public static @Prototype BitwiseAndLong_zxy get_proto() {
6716    return proto;
6717  }
6718
6719  /** instantiate an invariant on the specified slice */
6720  @Override
6721  protected BitwiseAndLong_zxy instantiate_dyn(@Prototype BitwiseAndLong_zxy this, PptSlice slice) {
6722    return new BitwiseAndLong_zxy (slice);
6723  }
6724
6725  private BitwiseAndLong_zxy (PptSlice slice) {
6726    super(slice);
6727  }
6728
6729  public @Prototype BitwiseAndLong_zxy () {
6730    super();
6731  }
6732
6733  private static String[] method_name = new String[] {"", " & ", ""};
6734
6735  @Override
6736  public String[] get_method_name(@GuardSatisfied BitwiseAndLong_zxy this) {
6737    return method_name;
6738  }
6739
6740  private static int function_id = -1;
6741
6742  @Override
6743  public int get_function_id() {
6744    return function_id;
6745  }
6746
6747  @Override
6748  public void set_function_id(int function_id) {
6749    assert BitwiseAndLong_zxy.function_id == -1;
6750    BitwiseAndLong_zxy.function_id = function_id;
6751  }
6752
6753  private static int var_order = 3;
6754
6755  @Override
6756  public int get_var_order(@GuardSatisfied BitwiseAndLong_zxy this) {
6757    return var_order;
6758  }
6759
6760  @Pure
6761  @Override
6762  public boolean is_symmetric() {
6763
6764      return true;
6765  }
6766
6767  @Override
6768
6769  public long func(long x, long y) {
6770
6771    return (x & y);
6772  }
6773
6774  @Override
6775  public InvariantStatus check_modified(long x, long y,
6776                                      long z, int count) {
6777    return check_ordered(z, x, y, count);
6778  }
6779
6780  @Override
6781  public InvariantStatus add_modified(long x, long y,
6782                                      long z, int count) {
6783    if (Debug.logDetail()) {
6784      log("result=%s, arg1=%s, arg2=%s", z, x, y);
6785    }
6786    return add_ordered(z, x, y, count);
6787  }
6788
6789  @Pure
6790  @Override
6791  public boolean isBitwiseAnd() {
6792    return true;
6793  }
6794
6795  @Pure
6796  @Override
6797  public boolean isExact() {
6798    return true;
6799  }
6800
6801  /** Returns a list of non-instantiating suppressions for this invariant. */
6802  @Pure
6803  @Override
6804  public @Nullable NISuppressionSet get_ni_suppressions() {
6805    if (NIS.dkconfig_enabled && dkconfig_enabled) {
6806      return suppressions;
6807    } else {
6808      return null;
6809    }
6810  }
6811
6812  /** definition of this invariant (the suppressee) */
6813  private static NISuppressee suppressee = new NISuppressee(BitwiseAndLong_zxy.class, 3);
6814
6815  // suppressor definitions (used below)
6816  private static NISuppressor result_eq_arg1 =
6817      new NISuppressor(2, 0, IntEqual.class);
6818  private static NISuppressor result_eq_arg2 =
6819      new NISuppressor(2, 1, IntEqual.class);
6820  private static NISuppressor arg1_eq_arg2 =
6821      new NISuppressor(0, 1, IntEqual.class);
6822
6823  private static NISuppressor result_lt_arg1 =
6824      new NISuppressor(2, 0, IntLessThan.class);
6825  private static NISuppressor result_lt_arg2 =
6826      new NISuppressor(2, 1, IntLessThan.class);
6827  private static NISuppressor arg1_lt_arg2 =
6828      new NISuppressor(0, 1, IntLessThan.class);
6829  private static NISuppressor arg2_lt_arg1 =
6830      new NISuppressor(1, 0, IntLessThan.class);
6831
6832  private static NISuppressor result_le_arg1 =
6833      new NISuppressor(2, 0, IntLessEqual.class);
6834  private static NISuppressor result_le_arg2 =
6835      new NISuppressor(2, 1, IntLessEqual.class);
6836  private static NISuppressor arg1_le_arg2 =
6837      new NISuppressor(0, 1, IntLessEqual.class);
6838  private static NISuppressor arg2_le_arg1 =
6839      new NISuppressor(1, 0, IntLessEqual.class);
6840
6841  private static NISuppressor result_track0_arg1 =
6842      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
6843  private static NISuppressor result_track0_arg2 =
6844      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
6845  private static NISuppressor arg1_track0_arg2 =
6846      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
6847  private static NISuppressor arg1_track0_result =
6848      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
6849  private static NISuppressor arg2_track0_result =
6850      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
6851  private static NISuppressor arg2_track0_arg1 =
6852      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
6853
6854  private static NISuppressor result_eq_1 =
6855      new NISuppressor(2, RangeInt.EqualOne.class);
6856  private static NISuppressor arg1_eq_1 =
6857      new NISuppressor(0, RangeInt.EqualOne.class);
6858  private static NISuppressor arg2_eq_1 =
6859      new NISuppressor(1, RangeInt.EqualOne.class);
6860
6861  private static NISuppressor result_eq_0 =
6862      new NISuppressor(2, RangeInt.EqualZero.class);
6863  private static NISuppressor arg1_eq_0 =
6864      new NISuppressor(0, RangeInt.EqualZero.class);
6865  private static NISuppressor arg2_eq_0 =
6866      new NISuppressor(1, RangeInt.EqualZero.class);
6867
6868  private static NISuppressor result_ne_0 =
6869      new NISuppressor(2, NonZero.class);
6870  private static NISuppressor arg1_ne_0 =
6871      new NISuppressor(0, NonZero.class);
6872  private static NISuppressor arg2_ne_0 =
6873      new NISuppressor(1, NonZero.class);
6874
6875  private static NISuppressor result_ge_0 =
6876      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
6877  private static NISuppressor arg1_ge_0 =
6878      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
6879  private static NISuppressor arg2_ge_0 =
6880      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
6881
6882  private static NISuppressor result_ge_64 =
6883      new NISuppressor(2, RangeInt.GreaterEqual64.class);
6884  private static NISuppressor arg1_ge_64 =
6885      new NISuppressor(0, RangeInt.GreaterEqual64.class);
6886  private static NISuppressor arg2_ge_64 =
6887      new NISuppressor(1, RangeInt.GreaterEqual64.class);
6888
6889  private static NISuppressor result_boolean =
6890      new NISuppressor(2, RangeInt.BooleanVal.class);
6891  private static NISuppressor arg1_boolean =
6892      new NISuppressor(0, RangeInt.BooleanVal.class);
6893  private static NISuppressor arg2_boolean =
6894      new NISuppressor(1, RangeInt.BooleanVal.class);
6895
6896  private static NISuppressor result_even =
6897      new NISuppressor(2, RangeInt.Even.class);
6898  private static NISuppressor arg1_even =
6899      new NISuppressor(0, RangeInt.Even.class);
6900  private static NISuppressor arg2_even =
6901      new NISuppressor(1, RangeInt.Even.class);
6902
6903  private static NISuppressor result_power2 =
6904      new NISuppressor(2, RangeInt.PowerOfTwo.class);
6905  private static NISuppressor arg1_power2 =
6906      new NISuppressor(0, RangeInt.PowerOfTwo.class);
6907  private static NISuppressor arg2_power2 =
6908      new NISuppressor(1, RangeInt.PowerOfTwo.class);
6909
6910  private static NISuppressor result_and0_arg1 =
6911      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
6912  private static NISuppressor result_and0_arg2 =
6913      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
6914  private static NISuppressor arg1_and0_arg2 =
6915      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
6916
6917  // The arguments to bitwise subset are backwards from what one
6918  // might expect.  The second argument is a subset of the first
6919  // argument
6920  private static NISuppressor arg1_bw_subset_arg2 =
6921      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
6922  private static NISuppressor arg2_bw_subset_arg1 =
6923      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
6924
6925  private static NISuppressor result_shift0_arg1 =
6926      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
6927  private static NISuppressor result_shift0_arg2 =
6928      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
6929  private static NISuppressor arg1_shift0_arg2 =
6930      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
6931
6932  private static NISuppressor arg2_divides_arg1 =
6933      new NISuppressor(0, 1, NumericInt.Divides.class);
6934  private static NISuppressor arg1_divides_arg2 =
6935      new NISuppressor(1, 0, NumericInt.Divides.class);
6936
6937  private static NISuppressor arg2_valid_shift =
6938      new NISuppressor(1, RangeInt.Bound0_63.class);
6939
6940    private static NISuppressionSet suppressions =
6941        new NISuppressionSet(
6942          new NISuppression[] {
6943
6944            // (r == x) && (x == y) && (r == y) ==> r = x &  y
6945            new NISuppression(result_eq_arg1, arg1_eq_arg2, result_eq_arg2,
6946                               suppressee),
6947
6948            // (r == x) && (x bitwise subset y)
6949            new NISuppression(result_eq_arg1, arg1_bw_subset_arg2, suppressee),
6950
6951            // (r == y) && (y bitwise subset x)
6952            new NISuppression(result_eq_arg2, arg2_bw_subset_arg1, suppressee),
6953
6954            // (r == 0) && (x & y == 0) ==> r = x & y
6955            new NISuppression(result_eq_0, arg1_and0_arg2, suppressee),
6956
6957            // All of these are subsummed by the prior one
6958            // (r == 0) && (x == 0) ==> r = x & y
6959            // new NISuppression (result_eq_0, arg1_eq_0, suppressee),
6960
6961            // (r == 0) && (y == 0) ==> r = x & y
6962            // new NISuppression (result_eq_0, arg2_eq_0, suppressee),
6963
6964            // (r == 0) && (x boolean) && (y is even)
6965            // new NISuppression (result_eq_0, arg1_boolean, arg2_even, suppressee),
6966
6967            // (r == 0) && (y boolean) && (x is even)
6968            // new NISuppression (result_eq_0, arg2_boolean, arg1_even, suppressee),
6969
6970            // (r == 0) && (y > x) && (y power2) && (x >= 0)
6971            // new NISuppression (result_eq_0, arg1_lt_arg2, arg2_power2, arg1_ge_0,
6972            //                   suppressee),
6973
6974            // (r == 0) && (x > y) && (x power2) && (y >= 0)
6975            // new NISuppression (result_eq_0, arg2_lt_arg1, arg1_power2, arg2_ge_0,
6976            //                   suppressee),
6977
6978            // (r == x) && (r boolean) && (y == 1)
6979            new NISuppression(result_eq_arg1, result_boolean, arg2_eq_1,
6980                               suppressee),
6981
6982            // (r == y) && (r boolean) && (x == 1)
6983            new NISuppression(result_eq_arg2, result_boolean, arg1_eq_1,
6984                               suppressee),
6985
6986          });
6987
6988  // Create a suppression factory for functionBinary
6989
6990}
6991
6992  // default is that it is not this function, overriden in the subclass
6993  @Pure
6994  public boolean isLogicalAnd() {
6995    return false;
6996  }
6997
6998/**
6999 * Represents the invariant {@code x = LogicalAnd(y, z)} over three long
7000 * scalars. For logical operations, Daikon treats 0 as false and all other values as true.
7001 */
7002public static class LogicalAndLong_xyz extends FunctionBinary {
7003  // We are Serializable, so we specify a version to allow changes to
7004  // method signatures without breaking serialization.  If you add or
7005  // remove fields, you should change this number to the current date.
7006  static final long serialVersionUID = 20031030L;
7007
7008  private static @Prototype LogicalAndLong_xyz proto = new @Prototype LogicalAndLong_xyz ();
7009
7010  /** Returns the prototype invariant for LogicalAndLong_xyz */
7011  public static @Prototype LogicalAndLong_xyz get_proto() {
7012    return proto;
7013  }
7014
7015  /** instantiate an invariant on the specified slice */
7016  @Override
7017  protected LogicalAndLong_xyz instantiate_dyn(@Prototype LogicalAndLong_xyz this, PptSlice slice) {
7018    return new LogicalAndLong_xyz (slice);
7019  }
7020
7021  private LogicalAndLong_xyz (PptSlice slice) {
7022    super(slice);
7023  }
7024
7025  public @Prototype LogicalAndLong_xyz () {
7026    super();
7027  }
7028
7029  private static String[] method_name = new String[] {"", " && ", ""};
7030
7031  @Override
7032  public String[] get_method_name(@GuardSatisfied LogicalAndLong_xyz this) {
7033    return method_name;
7034  }
7035
7036  private static int function_id = -1;
7037
7038  @Override
7039  public int get_function_id() {
7040    return function_id;
7041  }
7042
7043  @Override
7044  public void set_function_id(int function_id) {
7045    assert LogicalAndLong_xyz.function_id == -1;
7046    LogicalAndLong_xyz.function_id = function_id;
7047  }
7048
7049  private static int var_order = 1;
7050
7051  @Override
7052  public int get_var_order(@GuardSatisfied LogicalAndLong_xyz this) {
7053    return var_order;
7054  }
7055
7056  @Pure
7057  @Override
7058  public boolean is_symmetric() {
7059
7060      return true;
7061  }
7062
7063  @Override
7064
7065  public long func(long y, long z) {
7066
7067      if ((y < 0) || (y > 1)) {
7068        throw new ArithmeticException("arg1 (" + y + ") is not boolean ");
7069      }
7070      if ((z < 0) || (z > 1)) {
7071        throw new ArithmeticException("arg2 (" + z + ") is not boolean ");
7072      }
7073
7074    return (((y != 0) && ( z != 0)) ? 1 : 0);
7075  }
7076
7077  @Override
7078  public InvariantStatus check_modified(long x, long y,
7079                                      long z, int count) {
7080    return check_ordered(x, y, z, count);
7081  }
7082
7083  @Override
7084  public InvariantStatus add_modified(long x, long y,
7085                                      long z, int count) {
7086    if (Debug.logDetail()) {
7087      log("result=%s, arg1=%s, arg2=%s", x, y, z);
7088    }
7089    return add_ordered(x, y, z, count);
7090  }
7091
7092  @Pure
7093  @Override
7094  public boolean isLogicalAnd() {
7095    return true;
7096  }
7097
7098  /** Returns a list of non-instantiating suppressions for this invariant. */
7099  @Pure
7100  @Override
7101  public @Nullable NISuppressionSet get_ni_suppressions() {
7102    if (NIS.dkconfig_enabled && dkconfig_enabled) {
7103      return suppressions;
7104    } else {
7105      return null;
7106    }
7107  }
7108
7109  /** definition of this invariant (the suppressee) */
7110  private static NISuppressee suppressee = new NISuppressee(LogicalAndLong_xyz.class, 3);
7111
7112  // suppressor definitions (used below)
7113  private static NISuppressor result_eq_arg1 =
7114      new NISuppressor(0, 1, IntEqual.class);
7115  private static NISuppressor result_eq_arg2 =
7116      new NISuppressor(0, 2, IntEqual.class);
7117  private static NISuppressor arg1_eq_arg2 =
7118      new NISuppressor(1, 2, IntEqual.class);
7119
7120  private static NISuppressor result_lt_arg1 =
7121      new NISuppressor(0, 1, IntLessThan.class);
7122  private static NISuppressor result_lt_arg2 =
7123      new NISuppressor(0, 2, IntLessThan.class);
7124  private static NISuppressor arg1_lt_arg2 =
7125      new NISuppressor(1, 2, IntLessThan.class);
7126  private static NISuppressor arg2_lt_arg1 =
7127      new NISuppressor(2, 1, IntLessThan.class);
7128
7129  private static NISuppressor result_le_arg1 =
7130      new NISuppressor(0, 1, IntLessEqual.class);
7131  private static NISuppressor result_le_arg2 =
7132      new NISuppressor(0, 2, IntLessEqual.class);
7133  private static NISuppressor arg1_le_arg2 =
7134      new NISuppressor(1, 2, IntLessEqual.class);
7135  private static NISuppressor arg2_le_arg1 =
7136      new NISuppressor(2, 1, IntLessEqual.class);
7137
7138  private static NISuppressor result_track0_arg1 =
7139      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
7140  private static NISuppressor result_track0_arg2 =
7141      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
7142  private static NISuppressor arg1_track0_arg2 =
7143      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
7144  private static NISuppressor arg1_track0_result =
7145      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
7146  private static NISuppressor arg2_track0_result =
7147      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
7148  private static NISuppressor arg2_track0_arg1 =
7149      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
7150
7151  private static NISuppressor result_eq_1 =
7152      new NISuppressor(0, RangeInt.EqualOne.class);
7153  private static NISuppressor arg1_eq_1 =
7154      new NISuppressor(1, RangeInt.EqualOne.class);
7155  private static NISuppressor arg2_eq_1 =
7156      new NISuppressor(2, RangeInt.EqualOne.class);
7157
7158  private static NISuppressor result_eq_0 =
7159      new NISuppressor(0, RangeInt.EqualZero.class);
7160  private static NISuppressor arg1_eq_0 =
7161      new NISuppressor(1, RangeInt.EqualZero.class);
7162  private static NISuppressor arg2_eq_0 =
7163      new NISuppressor(2, RangeInt.EqualZero.class);
7164
7165  private static NISuppressor result_ne_0 =
7166      new NISuppressor(0, NonZero.class);
7167  private static NISuppressor arg1_ne_0 =
7168      new NISuppressor(1, NonZero.class);
7169  private static NISuppressor arg2_ne_0 =
7170      new NISuppressor(2, NonZero.class);
7171
7172  private static NISuppressor result_ge_0 =
7173      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
7174  private static NISuppressor arg1_ge_0 =
7175      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
7176  private static NISuppressor arg2_ge_0 =
7177      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
7178
7179  private static NISuppressor result_ge_64 =
7180      new NISuppressor(0, RangeInt.GreaterEqual64.class);
7181  private static NISuppressor arg1_ge_64 =
7182      new NISuppressor(1, RangeInt.GreaterEqual64.class);
7183  private static NISuppressor arg2_ge_64 =
7184      new NISuppressor(2, RangeInt.GreaterEqual64.class);
7185
7186  private static NISuppressor result_boolean =
7187      new NISuppressor(0, RangeInt.BooleanVal.class);
7188  private static NISuppressor arg1_boolean =
7189      new NISuppressor(1, RangeInt.BooleanVal.class);
7190  private static NISuppressor arg2_boolean =
7191      new NISuppressor(2, RangeInt.BooleanVal.class);
7192
7193  private static NISuppressor result_even =
7194      new NISuppressor(0, RangeInt.Even.class);
7195  private static NISuppressor arg1_even =
7196      new NISuppressor(1, RangeInt.Even.class);
7197  private static NISuppressor arg2_even =
7198      new NISuppressor(2, RangeInt.Even.class);
7199
7200  private static NISuppressor result_power2 =
7201      new NISuppressor(0, RangeInt.PowerOfTwo.class);
7202  private static NISuppressor arg1_power2 =
7203      new NISuppressor(1, RangeInt.PowerOfTwo.class);
7204  private static NISuppressor arg2_power2 =
7205      new NISuppressor(2, RangeInt.PowerOfTwo.class);
7206
7207  private static NISuppressor result_and0_arg1 =
7208      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
7209  private static NISuppressor result_and0_arg2 =
7210      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
7211  private static NISuppressor arg1_and0_arg2 =
7212      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
7213
7214  // The arguments to bitwise subset are backwards from what one
7215  // might expect.  The second argument is a subset of the first
7216  // argument
7217  private static NISuppressor arg1_bw_subset_arg2 =
7218      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
7219  private static NISuppressor arg2_bw_subset_arg1 =
7220      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
7221
7222  private static NISuppressor result_shift0_arg1 =
7223      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
7224  private static NISuppressor result_shift0_arg2 =
7225      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
7226  private static NISuppressor arg1_shift0_arg2 =
7227      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
7228
7229  private static NISuppressor arg2_divides_arg1 =
7230      new NISuppressor(1, 2, NumericInt.Divides.class);
7231  private static NISuppressor arg1_divides_arg2 =
7232      new NISuppressor(2, 1, NumericInt.Divides.class);
7233
7234  private static NISuppressor arg2_valid_shift =
7235      new NISuppressor(2, RangeInt.Bound0_63.class);
7236
7237    private static NISuppressionSet suppressions =
7238        new NISuppressionSet(
7239          new NISuppression[] {
7240
7241            // (r == y) && (y == z) && (r == z) && (r is boolean)
7242            //    ==> r = y && z
7243            new NISuppression(result_eq_arg1, arg1_eq_arg2, result_eq_arg2,
7244                               result_boolean, suppressee),
7245
7246            // (r == 0) && (y == 0) && (z is boolean) ==> r = y && z
7247            new NISuppression(result_eq_0, arg1_eq_0, arg2_boolean, suppressee),
7248
7249            // (r == 0) && (z == 0) && (y is boolean) ==> r = y && z
7250            new NISuppression(result_eq_0, arg2_eq_0, arg1_boolean, suppressee),
7251
7252            // (r == 0) && (y == 0) && (z boolean) ==> r = y && z
7253            new NISuppression(result_eq_0, arg1_eq_0, arg2_boolean, suppressee),
7254
7255            // (r == 0) && (z == 0) && (y boolean) ==> r = y && z
7256            new NISuppression(result_eq_0, arg2_eq_0, arg1_boolean, suppressee),
7257
7258            // (r == y) && (r boolean) && (z == 1)
7259            new NISuppression(result_eq_arg1, result_boolean, arg2_eq_1,
7260                               suppressee),
7261
7262            // (r == z) && (r boolean) && (y == 1)
7263            new NISuppression(result_eq_arg2, result_boolean, arg1_eq_1,
7264                               suppressee),
7265
7266          });
7267
7268  // Create a suppression factory for functionBinary
7269
7270}
7271
7272/**
7273 * Represents the invariant {@code y = LogicalAnd(x, z)} over three long
7274 * scalars. For logical operations, Daikon treats 0 as false and all other values as true.
7275 */
7276public static class LogicalAndLong_yxz extends FunctionBinary {
7277  // We are Serializable, so we specify a version to allow changes to
7278  // method signatures without breaking serialization.  If you add or
7279  // remove fields, you should change this number to the current date.
7280  static final long serialVersionUID = 20031030L;
7281
7282  private static @Prototype LogicalAndLong_yxz proto = new @Prototype LogicalAndLong_yxz ();
7283
7284  /** Returns the prototype invariant for LogicalAndLong_yxz */
7285  public static @Prototype LogicalAndLong_yxz get_proto() {
7286    return proto;
7287  }
7288
7289  /** instantiate an invariant on the specified slice */
7290  @Override
7291  protected LogicalAndLong_yxz instantiate_dyn(@Prototype LogicalAndLong_yxz this, PptSlice slice) {
7292    return new LogicalAndLong_yxz (slice);
7293  }
7294
7295  private LogicalAndLong_yxz (PptSlice slice) {
7296    super(slice);
7297  }
7298
7299  public @Prototype LogicalAndLong_yxz () {
7300    super();
7301  }
7302
7303  private static String[] method_name = new String[] {"", " && ", ""};
7304
7305  @Override
7306  public String[] get_method_name(@GuardSatisfied LogicalAndLong_yxz this) {
7307    return method_name;
7308  }
7309
7310  private static int function_id = -1;
7311
7312  @Override
7313  public int get_function_id() {
7314    return function_id;
7315  }
7316
7317  @Override
7318  public void set_function_id(int function_id) {
7319    assert LogicalAndLong_yxz.function_id == -1;
7320    LogicalAndLong_yxz.function_id = function_id;
7321  }
7322
7323  private static int var_order = 2;
7324
7325  @Override
7326  public int get_var_order(@GuardSatisfied LogicalAndLong_yxz this) {
7327    return var_order;
7328  }
7329
7330  @Pure
7331  @Override
7332  public boolean is_symmetric() {
7333
7334      return true;
7335  }
7336
7337  @Override
7338
7339  public long func(long x, long z) {
7340
7341      if ((x < 0) || (x > 1)) {
7342        throw new ArithmeticException("arg1 (" + x + ") is not boolean ");
7343      }
7344      if ((z < 0) || (z > 1)) {
7345        throw new ArithmeticException("arg2 (" + z + ") is not boolean ");
7346      }
7347
7348    return (((x != 0) && ( z != 0)) ? 1 : 0);
7349  }
7350
7351  @Override
7352  public InvariantStatus check_modified(long x, long y,
7353                                      long z, int count) {
7354    return check_ordered(y, x, z, count);
7355  }
7356
7357  @Override
7358  public InvariantStatus add_modified(long x, long y,
7359                                      long z, int count) {
7360    if (Debug.logDetail()) {
7361      log("result=%s, arg1=%s, arg2=%s", y, x, z);
7362    }
7363    return add_ordered(y, x, z, count);
7364  }
7365
7366  @Pure
7367  @Override
7368  public boolean isLogicalAnd() {
7369    return true;
7370  }
7371
7372  /** Returns a list of non-instantiating suppressions for this invariant. */
7373  @Pure
7374  @Override
7375  public @Nullable NISuppressionSet get_ni_suppressions() {
7376    if (NIS.dkconfig_enabled && dkconfig_enabled) {
7377      return suppressions;
7378    } else {
7379      return null;
7380    }
7381  }
7382
7383  /** definition of this invariant (the suppressee) */
7384  private static NISuppressee suppressee = new NISuppressee(LogicalAndLong_yxz.class, 3);
7385
7386  // suppressor definitions (used below)
7387  private static NISuppressor result_eq_arg1 =
7388      new NISuppressor(1, 0, IntEqual.class);
7389  private static NISuppressor result_eq_arg2 =
7390      new NISuppressor(1, 2, IntEqual.class);
7391  private static NISuppressor arg1_eq_arg2 =
7392      new NISuppressor(0, 2, IntEqual.class);
7393
7394  private static NISuppressor result_lt_arg1 =
7395      new NISuppressor(1, 0, IntLessThan.class);
7396  private static NISuppressor result_lt_arg2 =
7397      new NISuppressor(1, 2, IntLessThan.class);
7398  private static NISuppressor arg1_lt_arg2 =
7399      new NISuppressor(0, 2, IntLessThan.class);
7400  private static NISuppressor arg2_lt_arg1 =
7401      new NISuppressor(2, 0, IntLessThan.class);
7402
7403  private static NISuppressor result_le_arg1 =
7404      new NISuppressor(1, 0, IntLessEqual.class);
7405  private static NISuppressor result_le_arg2 =
7406      new NISuppressor(1, 2, IntLessEqual.class);
7407  private static NISuppressor arg1_le_arg2 =
7408      new NISuppressor(0, 2, IntLessEqual.class);
7409  private static NISuppressor arg2_le_arg1 =
7410      new NISuppressor(2, 0, IntLessEqual.class);
7411
7412  private static NISuppressor result_track0_arg1 =
7413      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
7414  private static NISuppressor result_track0_arg2 =
7415      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
7416  private static NISuppressor arg1_track0_arg2 =
7417      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
7418  private static NISuppressor arg1_track0_result =
7419      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
7420  private static NISuppressor arg2_track0_result =
7421      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
7422  private static NISuppressor arg2_track0_arg1 =
7423      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
7424
7425  private static NISuppressor result_eq_1 =
7426      new NISuppressor(1, RangeInt.EqualOne.class);
7427  private static NISuppressor arg1_eq_1 =
7428      new NISuppressor(0, RangeInt.EqualOne.class);
7429  private static NISuppressor arg2_eq_1 =
7430      new NISuppressor(2, RangeInt.EqualOne.class);
7431
7432  private static NISuppressor result_eq_0 =
7433      new NISuppressor(1, RangeInt.EqualZero.class);
7434  private static NISuppressor arg1_eq_0 =
7435      new NISuppressor(0, RangeInt.EqualZero.class);
7436  private static NISuppressor arg2_eq_0 =
7437      new NISuppressor(2, RangeInt.EqualZero.class);
7438
7439  private static NISuppressor result_ne_0 =
7440      new NISuppressor(1, NonZero.class);
7441  private static NISuppressor arg1_ne_0 =
7442      new NISuppressor(0, NonZero.class);
7443  private static NISuppressor arg2_ne_0 =
7444      new NISuppressor(2, NonZero.class);
7445
7446  private static NISuppressor result_ge_0 =
7447      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
7448  private static NISuppressor arg1_ge_0 =
7449      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
7450  private static NISuppressor arg2_ge_0 =
7451      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
7452
7453  private static NISuppressor result_ge_64 =
7454      new NISuppressor(1, RangeInt.GreaterEqual64.class);
7455  private static NISuppressor arg1_ge_64 =
7456      new NISuppressor(0, RangeInt.GreaterEqual64.class);
7457  private static NISuppressor arg2_ge_64 =
7458      new NISuppressor(2, RangeInt.GreaterEqual64.class);
7459
7460  private static NISuppressor result_boolean =
7461      new NISuppressor(1, RangeInt.BooleanVal.class);
7462  private static NISuppressor arg1_boolean =
7463      new NISuppressor(0, RangeInt.BooleanVal.class);
7464  private static NISuppressor arg2_boolean =
7465      new NISuppressor(2, RangeInt.BooleanVal.class);
7466
7467  private static NISuppressor result_even =
7468      new NISuppressor(1, RangeInt.Even.class);
7469  private static NISuppressor arg1_even =
7470      new NISuppressor(0, RangeInt.Even.class);
7471  private static NISuppressor arg2_even =
7472      new NISuppressor(2, RangeInt.Even.class);
7473
7474  private static NISuppressor result_power2 =
7475      new NISuppressor(1, RangeInt.PowerOfTwo.class);
7476  private static NISuppressor arg1_power2 =
7477      new NISuppressor(0, RangeInt.PowerOfTwo.class);
7478  private static NISuppressor arg2_power2 =
7479      new NISuppressor(2, RangeInt.PowerOfTwo.class);
7480
7481  private static NISuppressor result_and0_arg1 =
7482      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
7483  private static NISuppressor result_and0_arg2 =
7484      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
7485  private static NISuppressor arg1_and0_arg2 =
7486      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
7487
7488  // The arguments to bitwise subset are backwards from what one
7489  // might expect.  The second argument is a subset of the first
7490  // argument
7491  private static NISuppressor arg1_bw_subset_arg2 =
7492      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
7493  private static NISuppressor arg2_bw_subset_arg1 =
7494      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
7495
7496  private static NISuppressor result_shift0_arg1 =
7497      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
7498  private static NISuppressor result_shift0_arg2 =
7499      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
7500  private static NISuppressor arg1_shift0_arg2 =
7501      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
7502
7503  private static NISuppressor arg2_divides_arg1 =
7504      new NISuppressor(0, 2, NumericInt.Divides.class);
7505  private static NISuppressor arg1_divides_arg2 =
7506      new NISuppressor(2, 0, NumericInt.Divides.class);
7507
7508  private static NISuppressor arg2_valid_shift =
7509      new NISuppressor(2, RangeInt.Bound0_63.class);
7510
7511    private static NISuppressionSet suppressions =
7512        new NISuppressionSet(
7513          new NISuppression[] {
7514
7515            // (r == x) && (x == z) && (r == z) && (r is boolean)
7516            //    ==> r = x && z
7517            new NISuppression(result_eq_arg1, arg1_eq_arg2, result_eq_arg2,
7518                               result_boolean, suppressee),
7519
7520            // (r == 0) && (x == 0) && (z is boolean) ==> r = x && z
7521            new NISuppression(result_eq_0, arg1_eq_0, arg2_boolean, suppressee),
7522
7523            // (r == 0) && (z == 0) && (x is boolean) ==> r = x && z
7524            new NISuppression(result_eq_0, arg2_eq_0, arg1_boolean, suppressee),
7525
7526            // (r == 0) && (x == 0) && (z boolean) ==> r = x && z
7527            new NISuppression(result_eq_0, arg1_eq_0, arg2_boolean, suppressee),
7528
7529            // (r == 0) && (z == 0) && (x boolean) ==> r = x && z
7530            new NISuppression(result_eq_0, arg2_eq_0, arg1_boolean, suppressee),
7531
7532            // (r == x) && (r boolean) && (z == 1)
7533            new NISuppression(result_eq_arg1, result_boolean, arg2_eq_1,
7534                               suppressee),
7535
7536            // (r == z) && (r boolean) && (x == 1)
7537            new NISuppression(result_eq_arg2, result_boolean, arg1_eq_1,
7538                               suppressee),
7539
7540          });
7541
7542  // Create a suppression factory for functionBinary
7543
7544}
7545
7546/**
7547 * Represents the invariant {@code z = LogicalAnd(x, y)} over three long
7548 * scalars. For logical operations, Daikon treats 0 as false and all other values as true.
7549 */
7550public static class LogicalAndLong_zxy extends FunctionBinary {
7551  // We are Serializable, so we specify a version to allow changes to
7552  // method signatures without breaking serialization.  If you add or
7553  // remove fields, you should change this number to the current date.
7554  static final long serialVersionUID = 20031030L;
7555
7556  private static @Prototype LogicalAndLong_zxy proto = new @Prototype LogicalAndLong_zxy ();
7557
7558  /** Returns the prototype invariant for LogicalAndLong_zxy */
7559  public static @Prototype LogicalAndLong_zxy get_proto() {
7560    return proto;
7561  }
7562
7563  /** instantiate an invariant on the specified slice */
7564  @Override
7565  protected LogicalAndLong_zxy instantiate_dyn(@Prototype LogicalAndLong_zxy this, PptSlice slice) {
7566    return new LogicalAndLong_zxy (slice);
7567  }
7568
7569  private LogicalAndLong_zxy (PptSlice slice) {
7570    super(slice);
7571  }
7572
7573  public @Prototype LogicalAndLong_zxy () {
7574    super();
7575  }
7576
7577  private static String[] method_name = new String[] {"", " && ", ""};
7578
7579  @Override
7580  public String[] get_method_name(@GuardSatisfied LogicalAndLong_zxy this) {
7581    return method_name;
7582  }
7583
7584  private static int function_id = -1;
7585
7586  @Override
7587  public int get_function_id() {
7588    return function_id;
7589  }
7590
7591  @Override
7592  public void set_function_id(int function_id) {
7593    assert LogicalAndLong_zxy.function_id == -1;
7594    LogicalAndLong_zxy.function_id = function_id;
7595  }
7596
7597  private static int var_order = 3;
7598
7599  @Override
7600  public int get_var_order(@GuardSatisfied LogicalAndLong_zxy this) {
7601    return var_order;
7602  }
7603
7604  @Pure
7605  @Override
7606  public boolean is_symmetric() {
7607
7608      return true;
7609  }
7610
7611  @Override
7612
7613  public long func(long x, long y) {
7614
7615      if ((x < 0) || (x > 1)) {
7616        throw new ArithmeticException("arg1 (" + x + ") is not boolean ");
7617      }
7618      if ((y < 0) || (y > 1)) {
7619        throw new ArithmeticException("arg2 (" + y + ") is not boolean ");
7620      }
7621
7622    return (((x != 0) && ( y != 0)) ? 1 : 0);
7623  }
7624
7625  @Override
7626  public InvariantStatus check_modified(long x, long y,
7627                                      long z, int count) {
7628    return check_ordered(z, x, y, count);
7629  }
7630
7631  @Override
7632  public InvariantStatus add_modified(long x, long y,
7633                                      long z, int count) {
7634    if (Debug.logDetail()) {
7635      log("result=%s, arg1=%s, arg2=%s", z, x, y);
7636    }
7637    return add_ordered(z, x, y, count);
7638  }
7639
7640  @Pure
7641  @Override
7642  public boolean isLogicalAnd() {
7643    return true;
7644  }
7645
7646  /** Returns a list of non-instantiating suppressions for this invariant. */
7647  @Pure
7648  @Override
7649  public @Nullable NISuppressionSet get_ni_suppressions() {
7650    if (NIS.dkconfig_enabled && dkconfig_enabled) {
7651      return suppressions;
7652    } else {
7653      return null;
7654    }
7655  }
7656
7657  /** definition of this invariant (the suppressee) */
7658  private static NISuppressee suppressee = new NISuppressee(LogicalAndLong_zxy.class, 3);
7659
7660  // suppressor definitions (used below)
7661  private static NISuppressor result_eq_arg1 =
7662      new NISuppressor(2, 0, IntEqual.class);
7663  private static NISuppressor result_eq_arg2 =
7664      new NISuppressor(2, 1, IntEqual.class);
7665  private static NISuppressor arg1_eq_arg2 =
7666      new NISuppressor(0, 1, IntEqual.class);
7667
7668  private static NISuppressor result_lt_arg1 =
7669      new NISuppressor(2, 0, IntLessThan.class);
7670  private static NISuppressor result_lt_arg2 =
7671      new NISuppressor(2, 1, IntLessThan.class);
7672  private static NISuppressor arg1_lt_arg2 =
7673      new NISuppressor(0, 1, IntLessThan.class);
7674  private static NISuppressor arg2_lt_arg1 =
7675      new NISuppressor(1, 0, IntLessThan.class);
7676
7677  private static NISuppressor result_le_arg1 =
7678      new NISuppressor(2, 0, IntLessEqual.class);
7679  private static NISuppressor result_le_arg2 =
7680      new NISuppressor(2, 1, IntLessEqual.class);
7681  private static NISuppressor arg1_le_arg2 =
7682      new NISuppressor(0, 1, IntLessEqual.class);
7683  private static NISuppressor arg2_le_arg1 =
7684      new NISuppressor(1, 0, IntLessEqual.class);
7685
7686  private static NISuppressor result_track0_arg1 =
7687      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
7688  private static NISuppressor result_track0_arg2 =
7689      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
7690  private static NISuppressor arg1_track0_arg2 =
7691      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
7692  private static NISuppressor arg1_track0_result =
7693      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
7694  private static NISuppressor arg2_track0_result =
7695      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
7696  private static NISuppressor arg2_track0_arg1 =
7697      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
7698
7699  private static NISuppressor result_eq_1 =
7700      new NISuppressor(2, RangeInt.EqualOne.class);
7701  private static NISuppressor arg1_eq_1 =
7702      new NISuppressor(0, RangeInt.EqualOne.class);
7703  private static NISuppressor arg2_eq_1 =
7704      new NISuppressor(1, RangeInt.EqualOne.class);
7705
7706  private static NISuppressor result_eq_0 =
7707      new NISuppressor(2, RangeInt.EqualZero.class);
7708  private static NISuppressor arg1_eq_0 =
7709      new NISuppressor(0, RangeInt.EqualZero.class);
7710  private static NISuppressor arg2_eq_0 =
7711      new NISuppressor(1, RangeInt.EqualZero.class);
7712
7713  private static NISuppressor result_ne_0 =
7714      new NISuppressor(2, NonZero.class);
7715  private static NISuppressor arg1_ne_0 =
7716      new NISuppressor(0, NonZero.class);
7717  private static NISuppressor arg2_ne_0 =
7718      new NISuppressor(1, NonZero.class);
7719
7720  private static NISuppressor result_ge_0 =
7721      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
7722  private static NISuppressor arg1_ge_0 =
7723      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
7724  private static NISuppressor arg2_ge_0 =
7725      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
7726
7727  private static NISuppressor result_ge_64 =
7728      new NISuppressor(2, RangeInt.GreaterEqual64.class);
7729  private static NISuppressor arg1_ge_64 =
7730      new NISuppressor(0, RangeInt.GreaterEqual64.class);
7731  private static NISuppressor arg2_ge_64 =
7732      new NISuppressor(1, RangeInt.GreaterEqual64.class);
7733
7734  private static NISuppressor result_boolean =
7735      new NISuppressor(2, RangeInt.BooleanVal.class);
7736  private static NISuppressor arg1_boolean =
7737      new NISuppressor(0, RangeInt.BooleanVal.class);
7738  private static NISuppressor arg2_boolean =
7739      new NISuppressor(1, RangeInt.BooleanVal.class);
7740
7741  private static NISuppressor result_even =
7742      new NISuppressor(2, RangeInt.Even.class);
7743  private static NISuppressor arg1_even =
7744      new NISuppressor(0, RangeInt.Even.class);
7745  private static NISuppressor arg2_even =
7746      new NISuppressor(1, RangeInt.Even.class);
7747
7748  private static NISuppressor result_power2 =
7749      new NISuppressor(2, RangeInt.PowerOfTwo.class);
7750  private static NISuppressor arg1_power2 =
7751      new NISuppressor(0, RangeInt.PowerOfTwo.class);
7752  private static NISuppressor arg2_power2 =
7753      new NISuppressor(1, RangeInt.PowerOfTwo.class);
7754
7755  private static NISuppressor result_and0_arg1 =
7756      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
7757  private static NISuppressor result_and0_arg2 =
7758      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
7759  private static NISuppressor arg1_and0_arg2 =
7760      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
7761
7762  // The arguments to bitwise subset are backwards from what one
7763  // might expect.  The second argument is a subset of the first
7764  // argument
7765  private static NISuppressor arg1_bw_subset_arg2 =
7766      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
7767  private static NISuppressor arg2_bw_subset_arg1 =
7768      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
7769
7770  private static NISuppressor result_shift0_arg1 =
7771      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
7772  private static NISuppressor result_shift0_arg2 =
7773      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
7774  private static NISuppressor arg1_shift0_arg2 =
7775      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
7776
7777  private static NISuppressor arg2_divides_arg1 =
7778      new NISuppressor(0, 1, NumericInt.Divides.class);
7779  private static NISuppressor arg1_divides_arg2 =
7780      new NISuppressor(1, 0, NumericInt.Divides.class);
7781
7782  private static NISuppressor arg2_valid_shift =
7783      new NISuppressor(1, RangeInt.Bound0_63.class);
7784
7785    private static NISuppressionSet suppressions =
7786        new NISuppressionSet(
7787          new NISuppression[] {
7788
7789            // (r == x) && (x == y) && (r == y) && (r is boolean)
7790            //    ==> r = x && y
7791            new NISuppression(result_eq_arg1, arg1_eq_arg2, result_eq_arg2,
7792                               result_boolean, suppressee),
7793
7794            // (r == 0) && (x == 0) && (y is boolean) ==> r = x && y
7795            new NISuppression(result_eq_0, arg1_eq_0, arg2_boolean, suppressee),
7796
7797            // (r == 0) && (y == 0) && (x is boolean) ==> r = x && y
7798            new NISuppression(result_eq_0, arg2_eq_0, arg1_boolean, suppressee),
7799
7800            // (r == 0) && (x == 0) && (y boolean) ==> r = x && y
7801            new NISuppression(result_eq_0, arg1_eq_0, arg2_boolean, suppressee),
7802
7803            // (r == 0) && (y == 0) && (x boolean) ==> r = x && y
7804            new NISuppression(result_eq_0, arg2_eq_0, arg1_boolean, suppressee),
7805
7806            // (r == x) && (r boolean) && (y == 1)
7807            new NISuppression(result_eq_arg1, result_boolean, arg2_eq_1,
7808                               suppressee),
7809
7810            // (r == y) && (r boolean) && (x == 1)
7811            new NISuppression(result_eq_arg2, result_boolean, arg1_eq_1,
7812                               suppressee),
7813
7814          });
7815
7816  // Create a suppression factory for functionBinary
7817
7818}
7819
7820  // default is that it is not this function, overriden in the subclass
7821  @Pure
7822  public boolean isBitwiseXor() {
7823    return false;
7824  }
7825
7826/**
7827 * Represents the invariant {@code x = BitwiseXor(y, z)} over three long
7828 * scalars. 
7829 */
7830public static class BitwiseXorLong_xyz extends FunctionBinary {
7831  // We are Serializable, so we specify a version to allow changes to
7832  // method signatures without breaking serialization.  If you add or
7833  // remove fields, you should change this number to the current date.
7834  static final long serialVersionUID = 20031030L;
7835
7836  private static @Prototype BitwiseXorLong_xyz proto = new @Prototype BitwiseXorLong_xyz ();
7837
7838  /** Returns the prototype invariant for BitwiseXorLong_xyz */
7839  public static @Prototype BitwiseXorLong_xyz get_proto() {
7840    return proto;
7841  }
7842
7843  /** instantiate an invariant on the specified slice */
7844  @Override
7845  protected BitwiseXorLong_xyz instantiate_dyn(@Prototype BitwiseXorLong_xyz this, PptSlice slice) {
7846    return new BitwiseXorLong_xyz (slice);
7847  }
7848
7849  private BitwiseXorLong_xyz (PptSlice slice) {
7850    super(slice);
7851  }
7852
7853  public @Prototype BitwiseXorLong_xyz () {
7854    super();
7855  }
7856
7857  private static String[] method_name = new String[] {"", " ^ ", ""};
7858
7859  @Override
7860  public String[] get_method_name(@GuardSatisfied BitwiseXorLong_xyz this) {
7861    return method_name;
7862  }
7863
7864  private static int function_id = -1;
7865
7866  @Override
7867  public int get_function_id() {
7868    return function_id;
7869  }
7870
7871  @Override
7872  public void set_function_id(int function_id) {
7873    assert BitwiseXorLong_xyz.function_id == -1;
7874    BitwiseXorLong_xyz.function_id = function_id;
7875  }
7876
7877  private static int var_order = 1;
7878
7879  @Override
7880  public int get_var_order(@GuardSatisfied BitwiseXorLong_xyz this) {
7881    return var_order;
7882  }
7883
7884  @Pure
7885  @Override
7886  public boolean is_symmetric() {
7887
7888      return true;
7889  }
7890
7891  @Override
7892
7893  public long func(long y, long z) {
7894
7895    return (y ^ z);
7896  }
7897
7898  @Override
7899  public InvariantStatus check_modified(long x, long y,
7900                                      long z, int count) {
7901    return check_ordered(x, y, z, count);
7902  }
7903
7904  @Override
7905  public InvariantStatus add_modified(long x, long y,
7906                                      long z, int count) {
7907    if (Debug.logDetail()) {
7908      log("result=%s, arg1=%s, arg2=%s", x, y, z);
7909    }
7910    return add_ordered(x, y, z, count);
7911  }
7912
7913  @Pure
7914  @Override
7915  public boolean isBitwiseXor() {
7916    return true;
7917  }
7918
7919  /** Returns a list of non-instantiating suppressions for this invariant. */
7920  @Pure
7921  @Override
7922  public @Nullable NISuppressionSet get_ni_suppressions() {
7923    if (NIS.dkconfig_enabled && dkconfig_enabled) {
7924      return suppressions;
7925    } else {
7926      return null;
7927    }
7928  }
7929
7930  /** definition of this invariant (the suppressee) */
7931  private static NISuppressee suppressee = new NISuppressee(BitwiseXorLong_xyz.class, 3);
7932
7933  // suppressor definitions (used below)
7934  private static NISuppressor result_eq_arg1 =
7935      new NISuppressor(0, 1, IntEqual.class);
7936  private static NISuppressor result_eq_arg2 =
7937      new NISuppressor(0, 2, IntEqual.class);
7938  private static NISuppressor arg1_eq_arg2 =
7939      new NISuppressor(1, 2, IntEqual.class);
7940
7941  private static NISuppressor result_lt_arg1 =
7942      new NISuppressor(0, 1, IntLessThan.class);
7943  private static NISuppressor result_lt_arg2 =
7944      new NISuppressor(0, 2, IntLessThan.class);
7945  private static NISuppressor arg1_lt_arg2 =
7946      new NISuppressor(1, 2, IntLessThan.class);
7947  private static NISuppressor arg2_lt_arg1 =
7948      new NISuppressor(2, 1, IntLessThan.class);
7949
7950  private static NISuppressor result_le_arg1 =
7951      new NISuppressor(0, 1, IntLessEqual.class);
7952  private static NISuppressor result_le_arg2 =
7953      new NISuppressor(0, 2, IntLessEqual.class);
7954  private static NISuppressor arg1_le_arg2 =
7955      new NISuppressor(1, 2, IntLessEqual.class);
7956  private static NISuppressor arg2_le_arg1 =
7957      new NISuppressor(2, 1, IntLessEqual.class);
7958
7959  private static NISuppressor result_track0_arg1 =
7960      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
7961  private static NISuppressor result_track0_arg2 =
7962      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
7963  private static NISuppressor arg1_track0_arg2 =
7964      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
7965  private static NISuppressor arg1_track0_result =
7966      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
7967  private static NISuppressor arg2_track0_result =
7968      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
7969  private static NISuppressor arg2_track0_arg1 =
7970      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
7971
7972  private static NISuppressor result_eq_1 =
7973      new NISuppressor(0, RangeInt.EqualOne.class);
7974  private static NISuppressor arg1_eq_1 =
7975      new NISuppressor(1, RangeInt.EqualOne.class);
7976  private static NISuppressor arg2_eq_1 =
7977      new NISuppressor(2, RangeInt.EqualOne.class);
7978
7979  private static NISuppressor result_eq_0 =
7980      new NISuppressor(0, RangeInt.EqualZero.class);
7981  private static NISuppressor arg1_eq_0 =
7982      new NISuppressor(1, RangeInt.EqualZero.class);
7983  private static NISuppressor arg2_eq_0 =
7984      new NISuppressor(2, RangeInt.EqualZero.class);
7985
7986  private static NISuppressor result_ne_0 =
7987      new NISuppressor(0, NonZero.class);
7988  private static NISuppressor arg1_ne_0 =
7989      new NISuppressor(1, NonZero.class);
7990  private static NISuppressor arg2_ne_0 =
7991      new NISuppressor(2, NonZero.class);
7992
7993  private static NISuppressor result_ge_0 =
7994      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
7995  private static NISuppressor arg1_ge_0 =
7996      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
7997  private static NISuppressor arg2_ge_0 =
7998      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
7999
8000  private static NISuppressor result_ge_64 =
8001      new NISuppressor(0, RangeInt.GreaterEqual64.class);
8002  private static NISuppressor arg1_ge_64 =
8003      new NISuppressor(1, RangeInt.GreaterEqual64.class);
8004  private static NISuppressor arg2_ge_64 =
8005      new NISuppressor(2, RangeInt.GreaterEqual64.class);
8006
8007  private static NISuppressor result_boolean =
8008      new NISuppressor(0, RangeInt.BooleanVal.class);
8009  private static NISuppressor arg1_boolean =
8010      new NISuppressor(1, RangeInt.BooleanVal.class);
8011  private static NISuppressor arg2_boolean =
8012      new NISuppressor(2, RangeInt.BooleanVal.class);
8013
8014  private static NISuppressor result_even =
8015      new NISuppressor(0, RangeInt.Even.class);
8016  private static NISuppressor arg1_even =
8017      new NISuppressor(1, RangeInt.Even.class);
8018  private static NISuppressor arg2_even =
8019      new NISuppressor(2, RangeInt.Even.class);
8020
8021  private static NISuppressor result_power2 =
8022      new NISuppressor(0, RangeInt.PowerOfTwo.class);
8023  private static NISuppressor arg1_power2 =
8024      new NISuppressor(1, RangeInt.PowerOfTwo.class);
8025  private static NISuppressor arg2_power2 =
8026      new NISuppressor(2, RangeInt.PowerOfTwo.class);
8027
8028  private static NISuppressor result_and0_arg1 =
8029      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
8030  private static NISuppressor result_and0_arg2 =
8031      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
8032  private static NISuppressor arg1_and0_arg2 =
8033      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
8034
8035  // The arguments to bitwise subset are backwards from what one
8036  // might expect.  The second argument is a subset of the first
8037  // argument
8038  private static NISuppressor arg1_bw_subset_arg2 =
8039      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
8040  private static NISuppressor arg2_bw_subset_arg1 =
8041      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
8042
8043  private static NISuppressor result_shift0_arg1 =
8044      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
8045  private static NISuppressor result_shift0_arg2 =
8046      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
8047  private static NISuppressor arg1_shift0_arg2 =
8048      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
8049
8050  private static NISuppressor arg2_divides_arg1 =
8051      new NISuppressor(1, 2, NumericInt.Divides.class);
8052  private static NISuppressor arg1_divides_arg2 =
8053      new NISuppressor(2, 1, NumericInt.Divides.class);
8054
8055  private static NISuppressor arg2_valid_shift =
8056      new NISuppressor(2, RangeInt.Bound0_63.class);
8057
8058    private static NISuppressionSet suppressions =
8059        new NISuppressionSet(
8060          new NISuppression[] {
8061
8062            // (r == 0) && (y == z) ==> r = y ^ z
8063            new NISuppression(result_eq_0, arg1_eq_arg2, suppressee),
8064
8065            // (r == y) && (z == 0) ==> r = y ^ z
8066            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
8067
8068            // (r == z) && (y == 0) ==> r = y ^ z
8069            new NISuppression(result_eq_arg2, arg1_eq_0, suppressee),
8070
8071          });
8072
8073  // Create a suppression factory for functionBinary
8074
8075}
8076
8077/**
8078 * Represents the invariant {@code y = BitwiseXor(x, z)} over three long
8079 * scalars. 
8080 */
8081public static class BitwiseXorLong_yxz extends FunctionBinary {
8082  // We are Serializable, so we specify a version to allow changes to
8083  // method signatures without breaking serialization.  If you add or
8084  // remove fields, you should change this number to the current date.
8085  static final long serialVersionUID = 20031030L;
8086
8087  private static @Prototype BitwiseXorLong_yxz proto = new @Prototype BitwiseXorLong_yxz ();
8088
8089  /** Returns the prototype invariant for BitwiseXorLong_yxz */
8090  public static @Prototype BitwiseXorLong_yxz get_proto() {
8091    return proto;
8092  }
8093
8094  /** instantiate an invariant on the specified slice */
8095  @Override
8096  protected BitwiseXorLong_yxz instantiate_dyn(@Prototype BitwiseXorLong_yxz this, PptSlice slice) {
8097    return new BitwiseXorLong_yxz (slice);
8098  }
8099
8100  private BitwiseXorLong_yxz (PptSlice slice) {
8101    super(slice);
8102  }
8103
8104  public @Prototype BitwiseXorLong_yxz () {
8105    super();
8106  }
8107
8108  private static String[] method_name = new String[] {"", " ^ ", ""};
8109
8110  @Override
8111  public String[] get_method_name(@GuardSatisfied BitwiseXorLong_yxz this) {
8112    return method_name;
8113  }
8114
8115  private static int function_id = -1;
8116
8117  @Override
8118  public int get_function_id() {
8119    return function_id;
8120  }
8121
8122  @Override
8123  public void set_function_id(int function_id) {
8124    assert BitwiseXorLong_yxz.function_id == -1;
8125    BitwiseXorLong_yxz.function_id = function_id;
8126  }
8127
8128  private static int var_order = 2;
8129
8130  @Override
8131  public int get_var_order(@GuardSatisfied BitwiseXorLong_yxz this) {
8132    return var_order;
8133  }
8134
8135  @Pure
8136  @Override
8137  public boolean is_symmetric() {
8138
8139      return true;
8140  }
8141
8142  @Override
8143
8144  public long func(long x, long z) {
8145
8146    return (x ^ z);
8147  }
8148
8149  @Override
8150  public InvariantStatus check_modified(long x, long y,
8151                                      long z, int count) {
8152    return check_ordered(y, x, z, count);
8153  }
8154
8155  @Override
8156  public InvariantStatus add_modified(long x, long y,
8157                                      long z, int count) {
8158    if (Debug.logDetail()) {
8159      log("result=%s, arg1=%s, arg2=%s", y, x, z);
8160    }
8161    return add_ordered(y, x, z, count);
8162  }
8163
8164  @Pure
8165  @Override
8166  public boolean isBitwiseXor() {
8167    return true;
8168  }
8169
8170  /** Returns a list of non-instantiating suppressions for this invariant. */
8171  @Pure
8172  @Override
8173  public @Nullable NISuppressionSet get_ni_suppressions() {
8174    if (NIS.dkconfig_enabled && dkconfig_enabled) {
8175      return suppressions;
8176    } else {
8177      return null;
8178    }
8179  }
8180
8181  /** definition of this invariant (the suppressee) */
8182  private static NISuppressee suppressee = new NISuppressee(BitwiseXorLong_yxz.class, 3);
8183
8184  // suppressor definitions (used below)
8185  private static NISuppressor result_eq_arg1 =
8186      new NISuppressor(1, 0, IntEqual.class);
8187  private static NISuppressor result_eq_arg2 =
8188      new NISuppressor(1, 2, IntEqual.class);
8189  private static NISuppressor arg1_eq_arg2 =
8190      new NISuppressor(0, 2, IntEqual.class);
8191
8192  private static NISuppressor result_lt_arg1 =
8193      new NISuppressor(1, 0, IntLessThan.class);
8194  private static NISuppressor result_lt_arg2 =
8195      new NISuppressor(1, 2, IntLessThan.class);
8196  private static NISuppressor arg1_lt_arg2 =
8197      new NISuppressor(0, 2, IntLessThan.class);
8198  private static NISuppressor arg2_lt_arg1 =
8199      new NISuppressor(2, 0, IntLessThan.class);
8200
8201  private static NISuppressor result_le_arg1 =
8202      new NISuppressor(1, 0, IntLessEqual.class);
8203  private static NISuppressor result_le_arg2 =
8204      new NISuppressor(1, 2, IntLessEqual.class);
8205  private static NISuppressor arg1_le_arg2 =
8206      new NISuppressor(0, 2, IntLessEqual.class);
8207  private static NISuppressor arg2_le_arg1 =
8208      new NISuppressor(2, 0, IntLessEqual.class);
8209
8210  private static NISuppressor result_track0_arg1 =
8211      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
8212  private static NISuppressor result_track0_arg2 =
8213      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
8214  private static NISuppressor arg1_track0_arg2 =
8215      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
8216  private static NISuppressor arg1_track0_result =
8217      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
8218  private static NISuppressor arg2_track0_result =
8219      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
8220  private static NISuppressor arg2_track0_arg1 =
8221      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
8222
8223  private static NISuppressor result_eq_1 =
8224      new NISuppressor(1, RangeInt.EqualOne.class);
8225  private static NISuppressor arg1_eq_1 =
8226      new NISuppressor(0, RangeInt.EqualOne.class);
8227  private static NISuppressor arg2_eq_1 =
8228      new NISuppressor(2, RangeInt.EqualOne.class);
8229
8230  private static NISuppressor result_eq_0 =
8231      new NISuppressor(1, RangeInt.EqualZero.class);
8232  private static NISuppressor arg1_eq_0 =
8233      new NISuppressor(0, RangeInt.EqualZero.class);
8234  private static NISuppressor arg2_eq_0 =
8235      new NISuppressor(2, RangeInt.EqualZero.class);
8236
8237  private static NISuppressor result_ne_0 =
8238      new NISuppressor(1, NonZero.class);
8239  private static NISuppressor arg1_ne_0 =
8240      new NISuppressor(0, NonZero.class);
8241  private static NISuppressor arg2_ne_0 =
8242      new NISuppressor(2, NonZero.class);
8243
8244  private static NISuppressor result_ge_0 =
8245      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
8246  private static NISuppressor arg1_ge_0 =
8247      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
8248  private static NISuppressor arg2_ge_0 =
8249      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
8250
8251  private static NISuppressor result_ge_64 =
8252      new NISuppressor(1, RangeInt.GreaterEqual64.class);
8253  private static NISuppressor arg1_ge_64 =
8254      new NISuppressor(0, RangeInt.GreaterEqual64.class);
8255  private static NISuppressor arg2_ge_64 =
8256      new NISuppressor(2, RangeInt.GreaterEqual64.class);
8257
8258  private static NISuppressor result_boolean =
8259      new NISuppressor(1, RangeInt.BooleanVal.class);
8260  private static NISuppressor arg1_boolean =
8261      new NISuppressor(0, RangeInt.BooleanVal.class);
8262  private static NISuppressor arg2_boolean =
8263      new NISuppressor(2, RangeInt.BooleanVal.class);
8264
8265  private static NISuppressor result_even =
8266      new NISuppressor(1, RangeInt.Even.class);
8267  private static NISuppressor arg1_even =
8268      new NISuppressor(0, RangeInt.Even.class);
8269  private static NISuppressor arg2_even =
8270      new NISuppressor(2, RangeInt.Even.class);
8271
8272  private static NISuppressor result_power2 =
8273      new NISuppressor(1, RangeInt.PowerOfTwo.class);
8274  private static NISuppressor arg1_power2 =
8275      new NISuppressor(0, RangeInt.PowerOfTwo.class);
8276  private static NISuppressor arg2_power2 =
8277      new NISuppressor(2, RangeInt.PowerOfTwo.class);
8278
8279  private static NISuppressor result_and0_arg1 =
8280      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
8281  private static NISuppressor result_and0_arg2 =
8282      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
8283  private static NISuppressor arg1_and0_arg2 =
8284      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
8285
8286  // The arguments to bitwise subset are backwards from what one
8287  // might expect.  The second argument is a subset of the first
8288  // argument
8289  private static NISuppressor arg1_bw_subset_arg2 =
8290      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
8291  private static NISuppressor arg2_bw_subset_arg1 =
8292      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
8293
8294  private static NISuppressor result_shift0_arg1 =
8295      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
8296  private static NISuppressor result_shift0_arg2 =
8297      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
8298  private static NISuppressor arg1_shift0_arg2 =
8299      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
8300
8301  private static NISuppressor arg2_divides_arg1 =
8302      new NISuppressor(0, 2, NumericInt.Divides.class);
8303  private static NISuppressor arg1_divides_arg2 =
8304      new NISuppressor(2, 0, NumericInt.Divides.class);
8305
8306  private static NISuppressor arg2_valid_shift =
8307      new NISuppressor(2, RangeInt.Bound0_63.class);
8308
8309    private static NISuppressionSet suppressions =
8310        new NISuppressionSet(
8311          new NISuppression[] {
8312
8313            // (r == 0) && (x == z) ==> r = x ^ z
8314            new NISuppression(result_eq_0, arg1_eq_arg2, suppressee),
8315
8316            // (r == x) && (z == 0) ==> r = x ^ z
8317            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
8318
8319            // (r == z) && (x == 0) ==> r = x ^ z
8320            new NISuppression(result_eq_arg2, arg1_eq_0, suppressee),
8321
8322          });
8323
8324  // Create a suppression factory for functionBinary
8325
8326}
8327
8328/**
8329 * Represents the invariant {@code z = BitwiseXor(x, y)} over three long
8330 * scalars. 
8331 */
8332public static class BitwiseXorLong_zxy extends FunctionBinary {
8333  // We are Serializable, so we specify a version to allow changes to
8334  // method signatures without breaking serialization.  If you add or
8335  // remove fields, you should change this number to the current date.
8336  static final long serialVersionUID = 20031030L;
8337
8338  private static @Prototype BitwiseXorLong_zxy proto = new @Prototype BitwiseXorLong_zxy ();
8339
8340  /** Returns the prototype invariant for BitwiseXorLong_zxy */
8341  public static @Prototype BitwiseXorLong_zxy get_proto() {
8342    return proto;
8343  }
8344
8345  /** instantiate an invariant on the specified slice */
8346  @Override
8347  protected BitwiseXorLong_zxy instantiate_dyn(@Prototype BitwiseXorLong_zxy this, PptSlice slice) {
8348    return new BitwiseXorLong_zxy (slice);
8349  }
8350
8351  private BitwiseXorLong_zxy (PptSlice slice) {
8352    super(slice);
8353  }
8354
8355  public @Prototype BitwiseXorLong_zxy () {
8356    super();
8357  }
8358
8359  private static String[] method_name = new String[] {"", " ^ ", ""};
8360
8361  @Override
8362  public String[] get_method_name(@GuardSatisfied BitwiseXorLong_zxy this) {
8363    return method_name;
8364  }
8365
8366  private static int function_id = -1;
8367
8368  @Override
8369  public int get_function_id() {
8370    return function_id;
8371  }
8372
8373  @Override
8374  public void set_function_id(int function_id) {
8375    assert BitwiseXorLong_zxy.function_id == -1;
8376    BitwiseXorLong_zxy.function_id = function_id;
8377  }
8378
8379  private static int var_order = 3;
8380
8381  @Override
8382  public int get_var_order(@GuardSatisfied BitwiseXorLong_zxy this) {
8383    return var_order;
8384  }
8385
8386  @Pure
8387  @Override
8388  public boolean is_symmetric() {
8389
8390      return true;
8391  }
8392
8393  @Override
8394
8395  public long func(long x, long y) {
8396
8397    return (x ^ y);
8398  }
8399
8400  @Override
8401  public InvariantStatus check_modified(long x, long y,
8402                                      long z, int count) {
8403    return check_ordered(z, x, y, count);
8404  }
8405
8406  @Override
8407  public InvariantStatus add_modified(long x, long y,
8408                                      long z, int count) {
8409    if (Debug.logDetail()) {
8410      log("result=%s, arg1=%s, arg2=%s", z, x, y);
8411    }
8412    return add_ordered(z, x, y, count);
8413  }
8414
8415  @Pure
8416  @Override
8417  public boolean isBitwiseXor() {
8418    return true;
8419  }
8420
8421  /** Returns a list of non-instantiating suppressions for this invariant. */
8422  @Pure
8423  @Override
8424  public @Nullable NISuppressionSet get_ni_suppressions() {
8425    if (NIS.dkconfig_enabled && dkconfig_enabled) {
8426      return suppressions;
8427    } else {
8428      return null;
8429    }
8430  }
8431
8432  /** definition of this invariant (the suppressee) */
8433  private static NISuppressee suppressee = new NISuppressee(BitwiseXorLong_zxy.class, 3);
8434
8435  // suppressor definitions (used below)
8436  private static NISuppressor result_eq_arg1 =
8437      new NISuppressor(2, 0, IntEqual.class);
8438  private static NISuppressor result_eq_arg2 =
8439      new NISuppressor(2, 1, IntEqual.class);
8440  private static NISuppressor arg1_eq_arg2 =
8441      new NISuppressor(0, 1, IntEqual.class);
8442
8443  private static NISuppressor result_lt_arg1 =
8444      new NISuppressor(2, 0, IntLessThan.class);
8445  private static NISuppressor result_lt_arg2 =
8446      new NISuppressor(2, 1, IntLessThan.class);
8447  private static NISuppressor arg1_lt_arg2 =
8448      new NISuppressor(0, 1, IntLessThan.class);
8449  private static NISuppressor arg2_lt_arg1 =
8450      new NISuppressor(1, 0, IntLessThan.class);
8451
8452  private static NISuppressor result_le_arg1 =
8453      new NISuppressor(2, 0, IntLessEqual.class);
8454  private static NISuppressor result_le_arg2 =
8455      new NISuppressor(2, 1, IntLessEqual.class);
8456  private static NISuppressor arg1_le_arg2 =
8457      new NISuppressor(0, 1, IntLessEqual.class);
8458  private static NISuppressor arg2_le_arg1 =
8459      new NISuppressor(1, 0, IntLessEqual.class);
8460
8461  private static NISuppressor result_track0_arg1 =
8462      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
8463  private static NISuppressor result_track0_arg2 =
8464      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
8465  private static NISuppressor arg1_track0_arg2 =
8466      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
8467  private static NISuppressor arg1_track0_result =
8468      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
8469  private static NISuppressor arg2_track0_result =
8470      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
8471  private static NISuppressor arg2_track0_arg1 =
8472      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
8473
8474  private static NISuppressor result_eq_1 =
8475      new NISuppressor(2, RangeInt.EqualOne.class);
8476  private static NISuppressor arg1_eq_1 =
8477      new NISuppressor(0, RangeInt.EqualOne.class);
8478  private static NISuppressor arg2_eq_1 =
8479      new NISuppressor(1, RangeInt.EqualOne.class);
8480
8481  private static NISuppressor result_eq_0 =
8482      new NISuppressor(2, RangeInt.EqualZero.class);
8483  private static NISuppressor arg1_eq_0 =
8484      new NISuppressor(0, RangeInt.EqualZero.class);
8485  private static NISuppressor arg2_eq_0 =
8486      new NISuppressor(1, RangeInt.EqualZero.class);
8487
8488  private static NISuppressor result_ne_0 =
8489      new NISuppressor(2, NonZero.class);
8490  private static NISuppressor arg1_ne_0 =
8491      new NISuppressor(0, NonZero.class);
8492  private static NISuppressor arg2_ne_0 =
8493      new NISuppressor(1, NonZero.class);
8494
8495  private static NISuppressor result_ge_0 =
8496      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
8497  private static NISuppressor arg1_ge_0 =
8498      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
8499  private static NISuppressor arg2_ge_0 =
8500      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
8501
8502  private static NISuppressor result_ge_64 =
8503      new NISuppressor(2, RangeInt.GreaterEqual64.class);
8504  private static NISuppressor arg1_ge_64 =
8505      new NISuppressor(0, RangeInt.GreaterEqual64.class);
8506  private static NISuppressor arg2_ge_64 =
8507      new NISuppressor(1, RangeInt.GreaterEqual64.class);
8508
8509  private static NISuppressor result_boolean =
8510      new NISuppressor(2, RangeInt.BooleanVal.class);
8511  private static NISuppressor arg1_boolean =
8512      new NISuppressor(0, RangeInt.BooleanVal.class);
8513  private static NISuppressor arg2_boolean =
8514      new NISuppressor(1, RangeInt.BooleanVal.class);
8515
8516  private static NISuppressor result_even =
8517      new NISuppressor(2, RangeInt.Even.class);
8518  private static NISuppressor arg1_even =
8519      new NISuppressor(0, RangeInt.Even.class);
8520  private static NISuppressor arg2_even =
8521      new NISuppressor(1, RangeInt.Even.class);
8522
8523  private static NISuppressor result_power2 =
8524      new NISuppressor(2, RangeInt.PowerOfTwo.class);
8525  private static NISuppressor arg1_power2 =
8526      new NISuppressor(0, RangeInt.PowerOfTwo.class);
8527  private static NISuppressor arg2_power2 =
8528      new NISuppressor(1, RangeInt.PowerOfTwo.class);
8529
8530  private static NISuppressor result_and0_arg1 =
8531      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
8532  private static NISuppressor result_and0_arg2 =
8533      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
8534  private static NISuppressor arg1_and0_arg2 =
8535      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
8536
8537  // The arguments to bitwise subset are backwards from what one
8538  // might expect.  The second argument is a subset of the first
8539  // argument
8540  private static NISuppressor arg1_bw_subset_arg2 =
8541      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
8542  private static NISuppressor arg2_bw_subset_arg1 =
8543      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
8544
8545  private static NISuppressor result_shift0_arg1 =
8546      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
8547  private static NISuppressor result_shift0_arg2 =
8548      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
8549  private static NISuppressor arg1_shift0_arg2 =
8550      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
8551
8552  private static NISuppressor arg2_divides_arg1 =
8553      new NISuppressor(0, 1, NumericInt.Divides.class);
8554  private static NISuppressor arg1_divides_arg2 =
8555      new NISuppressor(1, 0, NumericInt.Divides.class);
8556
8557  private static NISuppressor arg2_valid_shift =
8558      new NISuppressor(1, RangeInt.Bound0_63.class);
8559
8560    private static NISuppressionSet suppressions =
8561        new NISuppressionSet(
8562          new NISuppression[] {
8563
8564            // (r == 0) && (x == y) ==> r = x ^ y
8565            new NISuppression(result_eq_0, arg1_eq_arg2, suppressee),
8566
8567            // (r == x) && (y == 0) ==> r = x ^ y
8568            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
8569
8570            // (r == y) && (x == 0) ==> r = x ^ y
8571            new NISuppression(result_eq_arg2, arg1_eq_0, suppressee),
8572
8573          });
8574
8575  // Create a suppression factory for functionBinary
8576
8577}
8578
8579  // #define METHOD_NAME {"", " ^ ", ""}
8580
8581  // default is that it is not this function, overriden in the subclass
8582  @Pure
8583  public boolean isLogicalXor() {
8584    return false;
8585  }
8586
8587/**
8588 * Represents the invariant {@code x = LogicalXor(y, z)} over three long
8589 * scalars. For logical operations, Daikon treats 0 as false and all other values as true.
8590 */
8591public static class LogicalXorLong_xyz extends FunctionBinary {
8592  // We are Serializable, so we specify a version to allow changes to
8593  // method signatures without breaking serialization.  If you add or
8594  // remove fields, you should change this number to the current date.
8595  static final long serialVersionUID = 20031030L;
8596
8597  private static @Prototype LogicalXorLong_xyz proto = new @Prototype LogicalXorLong_xyz ();
8598
8599  /** Returns the prototype invariant for LogicalXorLong_xyz */
8600  public static @Prototype LogicalXorLong_xyz get_proto() {
8601    return proto;
8602  }
8603
8604  /** instantiate an invariant on the specified slice */
8605  @Override
8606  protected LogicalXorLong_xyz instantiate_dyn(@Prototype LogicalXorLong_xyz this, PptSlice slice) {
8607    return new LogicalXorLong_xyz (slice);
8608  }
8609
8610  private LogicalXorLong_xyz (PptSlice slice) {
8611    super(slice);
8612  }
8613
8614  public @Prototype LogicalXorLong_xyz () {
8615    super();
8616  }
8617
8618  private static String[] method_name = new String[] {"org.plumelib.util.MathPlume.logicalXor(", ", ", ")"};
8619
8620  @Override
8621  public String[] get_method_name(@GuardSatisfied LogicalXorLong_xyz this) {
8622    return method_name;
8623  }
8624
8625  private static int function_id = -1;
8626
8627  @Override
8628  public int get_function_id() {
8629    return function_id;
8630  }
8631
8632  @Override
8633  public void set_function_id(int function_id) {
8634    assert LogicalXorLong_xyz.function_id == -1;
8635    LogicalXorLong_xyz.function_id = function_id;
8636  }
8637
8638  private static int var_order = 1;
8639
8640  @Override
8641  public int get_var_order(@GuardSatisfied LogicalXorLong_xyz this) {
8642    return var_order;
8643  }
8644
8645  @Pure
8646  @Override
8647  public boolean is_symmetric() {
8648
8649      return true;
8650  }
8651
8652  @Override
8653
8654  public long func(long y, long z) {
8655
8656      if ((y < 0) || (y > 1)) {
8657        throw new ArithmeticException("arg1 (" + y + ") is not boolean ");
8658      }
8659      if ((z < 0) || (z > 1)) {
8660        throw new ArithmeticException("arg2 (" + z + ") is not boolean ");
8661      }
8662
8663    return (((y != 0) ^ ( z != 0)) ? 1 : 0);
8664  }
8665
8666  @Override
8667  public InvariantStatus check_modified(long x, long y,
8668                                      long z, int count) {
8669    return check_ordered(x, y, z, count);
8670  }
8671
8672  @Override
8673  public InvariantStatus add_modified(long x, long y,
8674                                      long z, int count) {
8675    if (Debug.logDetail()) {
8676      log("result=%s, arg1=%s, arg2=%s", x, y, z);
8677    }
8678    return add_ordered(x, y, z, count);
8679  }
8680
8681  @Pure
8682  @Override
8683  public boolean isLogicalXor() {
8684    return true;
8685  }
8686
8687  /** Returns a list of non-instantiating suppressions for this invariant. */
8688  @Pure
8689  @Override
8690  public @Nullable NISuppressionSet get_ni_suppressions() {
8691    if (NIS.dkconfig_enabled && dkconfig_enabled) {
8692      return suppressions;
8693    } else {
8694      return null;
8695    }
8696  }
8697
8698  /** definition of this invariant (the suppressee) */
8699  private static NISuppressee suppressee = new NISuppressee(LogicalXorLong_xyz.class, 3);
8700
8701  // suppressor definitions (used below)
8702  private static NISuppressor result_eq_arg1 =
8703      new NISuppressor(0, 1, IntEqual.class);
8704  private static NISuppressor result_eq_arg2 =
8705      new NISuppressor(0, 2, IntEqual.class);
8706  private static NISuppressor arg1_eq_arg2 =
8707      new NISuppressor(1, 2, IntEqual.class);
8708
8709  private static NISuppressor result_lt_arg1 =
8710      new NISuppressor(0, 1, IntLessThan.class);
8711  private static NISuppressor result_lt_arg2 =
8712      new NISuppressor(0, 2, IntLessThan.class);
8713  private static NISuppressor arg1_lt_arg2 =
8714      new NISuppressor(1, 2, IntLessThan.class);
8715  private static NISuppressor arg2_lt_arg1 =
8716      new NISuppressor(2, 1, IntLessThan.class);
8717
8718  private static NISuppressor result_le_arg1 =
8719      new NISuppressor(0, 1, IntLessEqual.class);
8720  private static NISuppressor result_le_arg2 =
8721      new NISuppressor(0, 2, IntLessEqual.class);
8722  private static NISuppressor arg1_le_arg2 =
8723      new NISuppressor(1, 2, IntLessEqual.class);
8724  private static NISuppressor arg2_le_arg1 =
8725      new NISuppressor(2, 1, IntLessEqual.class);
8726
8727  private static NISuppressor result_track0_arg1 =
8728      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
8729  private static NISuppressor result_track0_arg2 =
8730      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
8731  private static NISuppressor arg1_track0_arg2 =
8732      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
8733  private static NISuppressor arg1_track0_result =
8734      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
8735  private static NISuppressor arg2_track0_result =
8736      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
8737  private static NISuppressor arg2_track0_arg1 =
8738      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
8739
8740  private static NISuppressor result_eq_1 =
8741      new NISuppressor(0, RangeInt.EqualOne.class);
8742  private static NISuppressor arg1_eq_1 =
8743      new NISuppressor(1, RangeInt.EqualOne.class);
8744  private static NISuppressor arg2_eq_1 =
8745      new NISuppressor(2, RangeInt.EqualOne.class);
8746
8747  private static NISuppressor result_eq_0 =
8748      new NISuppressor(0, RangeInt.EqualZero.class);
8749  private static NISuppressor arg1_eq_0 =
8750      new NISuppressor(1, RangeInt.EqualZero.class);
8751  private static NISuppressor arg2_eq_0 =
8752      new NISuppressor(2, RangeInt.EqualZero.class);
8753
8754  private static NISuppressor result_ne_0 =
8755      new NISuppressor(0, NonZero.class);
8756  private static NISuppressor arg1_ne_0 =
8757      new NISuppressor(1, NonZero.class);
8758  private static NISuppressor arg2_ne_0 =
8759      new NISuppressor(2, NonZero.class);
8760
8761  private static NISuppressor result_ge_0 =
8762      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
8763  private static NISuppressor arg1_ge_0 =
8764      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
8765  private static NISuppressor arg2_ge_0 =
8766      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
8767
8768  private static NISuppressor result_ge_64 =
8769      new NISuppressor(0, RangeInt.GreaterEqual64.class);
8770  private static NISuppressor arg1_ge_64 =
8771      new NISuppressor(1, RangeInt.GreaterEqual64.class);
8772  private static NISuppressor arg2_ge_64 =
8773      new NISuppressor(2, RangeInt.GreaterEqual64.class);
8774
8775  private static NISuppressor result_boolean =
8776      new NISuppressor(0, RangeInt.BooleanVal.class);
8777  private static NISuppressor arg1_boolean =
8778      new NISuppressor(1, RangeInt.BooleanVal.class);
8779  private static NISuppressor arg2_boolean =
8780      new NISuppressor(2, RangeInt.BooleanVal.class);
8781
8782  private static NISuppressor result_even =
8783      new NISuppressor(0, RangeInt.Even.class);
8784  private static NISuppressor arg1_even =
8785      new NISuppressor(1, RangeInt.Even.class);
8786  private static NISuppressor arg2_even =
8787      new NISuppressor(2, RangeInt.Even.class);
8788
8789  private static NISuppressor result_power2 =
8790      new NISuppressor(0, RangeInt.PowerOfTwo.class);
8791  private static NISuppressor arg1_power2 =
8792      new NISuppressor(1, RangeInt.PowerOfTwo.class);
8793  private static NISuppressor arg2_power2 =
8794      new NISuppressor(2, RangeInt.PowerOfTwo.class);
8795
8796  private static NISuppressor result_and0_arg1 =
8797      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
8798  private static NISuppressor result_and0_arg2 =
8799      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
8800  private static NISuppressor arg1_and0_arg2 =
8801      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
8802
8803  // The arguments to bitwise subset are backwards from what one
8804  // might expect.  The second argument is a subset of the first
8805  // argument
8806  private static NISuppressor arg1_bw_subset_arg2 =
8807      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
8808  private static NISuppressor arg2_bw_subset_arg1 =
8809      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
8810
8811  private static NISuppressor result_shift0_arg1 =
8812      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
8813  private static NISuppressor result_shift0_arg2 =
8814      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
8815  private static NISuppressor arg1_shift0_arg2 =
8816      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
8817
8818  private static NISuppressor arg2_divides_arg1 =
8819      new NISuppressor(1, 2, NumericInt.Divides.class);
8820  private static NISuppressor arg1_divides_arg2 =
8821      new NISuppressor(2, 1, NumericInt.Divides.class);
8822
8823  private static NISuppressor arg2_valid_shift =
8824      new NISuppressor(2, RangeInt.Bound0_63.class);
8825
8826    private static NISuppressionSet suppressions =
8827        new NISuppressionSet(
8828          new NISuppression[] {
8829
8830            // (r == 0) && (y == z) && (y boolean) ==> r = y ^ z
8831            new NISuppression(arg1_eq_arg2, arg1_boolean, result_eq_0,
8832                               suppressee),
8833
8834            // (r == y) && (z == 0) && (x boolean) ==> r = y ^ z
8835            new NISuppression(result_eq_arg1, result_boolean, arg2_eq_0,
8836                               suppressee),
8837
8838            // (r == z) && (y == 0) && (x boolean)==> r = y ^ z
8839            new NISuppression(result_eq_arg2, result_boolean, arg1_eq_0,
8840                               suppressee),
8841
8842          });
8843
8844  // Create a suppression factory for functionBinary
8845
8846}
8847
8848/**
8849 * Represents the invariant {@code y = LogicalXor(x, z)} over three long
8850 * scalars. For logical operations, Daikon treats 0 as false and all other values as true.
8851 */
8852public static class LogicalXorLong_yxz extends FunctionBinary {
8853  // We are Serializable, so we specify a version to allow changes to
8854  // method signatures without breaking serialization.  If you add or
8855  // remove fields, you should change this number to the current date.
8856  static final long serialVersionUID = 20031030L;
8857
8858  private static @Prototype LogicalXorLong_yxz proto = new @Prototype LogicalXorLong_yxz ();
8859
8860  /** Returns the prototype invariant for LogicalXorLong_yxz */
8861  public static @Prototype LogicalXorLong_yxz get_proto() {
8862    return proto;
8863  }
8864
8865  /** instantiate an invariant on the specified slice */
8866  @Override
8867  protected LogicalXorLong_yxz instantiate_dyn(@Prototype LogicalXorLong_yxz this, PptSlice slice) {
8868    return new LogicalXorLong_yxz (slice);
8869  }
8870
8871  private LogicalXorLong_yxz (PptSlice slice) {
8872    super(slice);
8873  }
8874
8875  public @Prototype LogicalXorLong_yxz () {
8876    super();
8877  }
8878
8879  private static String[] method_name = new String[] {"org.plumelib.util.MathPlume.logicalXor(", ", ", ")"};
8880
8881  @Override
8882  public String[] get_method_name(@GuardSatisfied LogicalXorLong_yxz this) {
8883    return method_name;
8884  }
8885
8886  private static int function_id = -1;
8887
8888  @Override
8889  public int get_function_id() {
8890    return function_id;
8891  }
8892
8893  @Override
8894  public void set_function_id(int function_id) {
8895    assert LogicalXorLong_yxz.function_id == -1;
8896    LogicalXorLong_yxz.function_id = function_id;
8897  }
8898
8899  private static int var_order = 2;
8900
8901  @Override
8902  public int get_var_order(@GuardSatisfied LogicalXorLong_yxz this) {
8903    return var_order;
8904  }
8905
8906  @Pure
8907  @Override
8908  public boolean is_symmetric() {
8909
8910      return true;
8911  }
8912
8913  @Override
8914
8915  public long func(long x, long z) {
8916
8917      if ((x < 0) || (x > 1)) {
8918        throw new ArithmeticException("arg1 (" + x + ") is not boolean ");
8919      }
8920      if ((z < 0) || (z > 1)) {
8921        throw new ArithmeticException("arg2 (" + z + ") is not boolean ");
8922      }
8923
8924    return (((x != 0) ^ ( z != 0)) ? 1 : 0);
8925  }
8926
8927  @Override
8928  public InvariantStatus check_modified(long x, long y,
8929                                      long z, int count) {
8930    return check_ordered(y, x, z, count);
8931  }
8932
8933  @Override
8934  public InvariantStatus add_modified(long x, long y,
8935                                      long z, int count) {
8936    if (Debug.logDetail()) {
8937      log("result=%s, arg1=%s, arg2=%s", y, x, z);
8938    }
8939    return add_ordered(y, x, z, count);
8940  }
8941
8942  @Pure
8943  @Override
8944  public boolean isLogicalXor() {
8945    return true;
8946  }
8947
8948  /** Returns a list of non-instantiating suppressions for this invariant. */
8949  @Pure
8950  @Override
8951  public @Nullable NISuppressionSet get_ni_suppressions() {
8952    if (NIS.dkconfig_enabled && dkconfig_enabled) {
8953      return suppressions;
8954    } else {
8955      return null;
8956    }
8957  }
8958
8959  /** definition of this invariant (the suppressee) */
8960  private static NISuppressee suppressee = new NISuppressee(LogicalXorLong_yxz.class, 3);
8961
8962  // suppressor definitions (used below)
8963  private static NISuppressor result_eq_arg1 =
8964      new NISuppressor(1, 0, IntEqual.class);
8965  private static NISuppressor result_eq_arg2 =
8966      new NISuppressor(1, 2, IntEqual.class);
8967  private static NISuppressor arg1_eq_arg2 =
8968      new NISuppressor(0, 2, IntEqual.class);
8969
8970  private static NISuppressor result_lt_arg1 =
8971      new NISuppressor(1, 0, IntLessThan.class);
8972  private static NISuppressor result_lt_arg2 =
8973      new NISuppressor(1, 2, IntLessThan.class);
8974  private static NISuppressor arg1_lt_arg2 =
8975      new NISuppressor(0, 2, IntLessThan.class);
8976  private static NISuppressor arg2_lt_arg1 =
8977      new NISuppressor(2, 0, IntLessThan.class);
8978
8979  private static NISuppressor result_le_arg1 =
8980      new NISuppressor(1, 0, IntLessEqual.class);
8981  private static NISuppressor result_le_arg2 =
8982      new NISuppressor(1, 2, IntLessEqual.class);
8983  private static NISuppressor arg1_le_arg2 =
8984      new NISuppressor(0, 2, IntLessEqual.class);
8985  private static NISuppressor arg2_le_arg1 =
8986      new NISuppressor(2, 0, IntLessEqual.class);
8987
8988  private static NISuppressor result_track0_arg1 =
8989      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
8990  private static NISuppressor result_track0_arg2 =
8991      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
8992  private static NISuppressor arg1_track0_arg2 =
8993      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
8994  private static NISuppressor arg1_track0_result =
8995      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
8996  private static NISuppressor arg2_track0_result =
8997      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
8998  private static NISuppressor arg2_track0_arg1 =
8999      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
9000
9001  private static NISuppressor result_eq_1 =
9002      new NISuppressor(1, RangeInt.EqualOne.class);
9003  private static NISuppressor arg1_eq_1 =
9004      new NISuppressor(0, RangeInt.EqualOne.class);
9005  private static NISuppressor arg2_eq_1 =
9006      new NISuppressor(2, RangeInt.EqualOne.class);
9007
9008  private static NISuppressor result_eq_0 =
9009      new NISuppressor(1, RangeInt.EqualZero.class);
9010  private static NISuppressor arg1_eq_0 =
9011      new NISuppressor(0, RangeInt.EqualZero.class);
9012  private static NISuppressor arg2_eq_0 =
9013      new NISuppressor(2, RangeInt.EqualZero.class);
9014
9015  private static NISuppressor result_ne_0 =
9016      new NISuppressor(1, NonZero.class);
9017  private static NISuppressor arg1_ne_0 =
9018      new NISuppressor(0, NonZero.class);
9019  private static NISuppressor arg2_ne_0 =
9020      new NISuppressor(2, NonZero.class);
9021
9022  private static NISuppressor result_ge_0 =
9023      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
9024  private static NISuppressor arg1_ge_0 =
9025      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
9026  private static NISuppressor arg2_ge_0 =
9027      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
9028
9029  private static NISuppressor result_ge_64 =
9030      new NISuppressor(1, RangeInt.GreaterEqual64.class);
9031  private static NISuppressor arg1_ge_64 =
9032      new NISuppressor(0, RangeInt.GreaterEqual64.class);
9033  private static NISuppressor arg2_ge_64 =
9034      new NISuppressor(2, RangeInt.GreaterEqual64.class);
9035
9036  private static NISuppressor result_boolean =
9037      new NISuppressor(1, RangeInt.BooleanVal.class);
9038  private static NISuppressor arg1_boolean =
9039      new NISuppressor(0, RangeInt.BooleanVal.class);
9040  private static NISuppressor arg2_boolean =
9041      new NISuppressor(2, RangeInt.BooleanVal.class);
9042
9043  private static NISuppressor result_even =
9044      new NISuppressor(1, RangeInt.Even.class);
9045  private static NISuppressor arg1_even =
9046      new NISuppressor(0, RangeInt.Even.class);
9047  private static NISuppressor arg2_even =
9048      new NISuppressor(2, RangeInt.Even.class);
9049
9050  private static NISuppressor result_power2 =
9051      new NISuppressor(1, RangeInt.PowerOfTwo.class);
9052  private static NISuppressor arg1_power2 =
9053      new NISuppressor(0, RangeInt.PowerOfTwo.class);
9054  private static NISuppressor arg2_power2 =
9055      new NISuppressor(2, RangeInt.PowerOfTwo.class);
9056
9057  private static NISuppressor result_and0_arg1 =
9058      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
9059  private static NISuppressor result_and0_arg2 =
9060      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
9061  private static NISuppressor arg1_and0_arg2 =
9062      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
9063
9064  // The arguments to bitwise subset are backwards from what one
9065  // might expect.  The second argument is a subset of the first
9066  // argument
9067  private static NISuppressor arg1_bw_subset_arg2 =
9068      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
9069  private static NISuppressor arg2_bw_subset_arg1 =
9070      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
9071
9072  private static NISuppressor result_shift0_arg1 =
9073      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
9074  private static NISuppressor result_shift0_arg2 =
9075      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
9076  private static NISuppressor arg1_shift0_arg2 =
9077      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
9078
9079  private static NISuppressor arg2_divides_arg1 =
9080      new NISuppressor(0, 2, NumericInt.Divides.class);
9081  private static NISuppressor arg1_divides_arg2 =
9082      new NISuppressor(2, 0, NumericInt.Divides.class);
9083
9084  private static NISuppressor arg2_valid_shift =
9085      new NISuppressor(2, RangeInt.Bound0_63.class);
9086
9087    private static NISuppressionSet suppressions =
9088        new NISuppressionSet(
9089          new NISuppression[] {
9090
9091            // (r == 0) && (x == z) && (x boolean) ==> r = x ^ z
9092            new NISuppression(arg1_eq_arg2, arg1_boolean, result_eq_0,
9093                               suppressee),
9094
9095            // (r == x) && (z == 0) && (y boolean) ==> r = x ^ z
9096            new NISuppression(result_eq_arg1, result_boolean, arg2_eq_0,
9097                               suppressee),
9098
9099            // (r == z) && (x == 0) && (y boolean)==> r = x ^ z
9100            new NISuppression(result_eq_arg2, result_boolean, arg1_eq_0,
9101                               suppressee),
9102
9103          });
9104
9105  // Create a suppression factory for functionBinary
9106
9107}
9108
9109/**
9110 * Represents the invariant {@code z = LogicalXor(x, y)} over three long
9111 * scalars. For logical operations, Daikon treats 0 as false and all other values as true.
9112 */
9113public static class LogicalXorLong_zxy extends FunctionBinary {
9114  // We are Serializable, so we specify a version to allow changes to
9115  // method signatures without breaking serialization.  If you add or
9116  // remove fields, you should change this number to the current date.
9117  static final long serialVersionUID = 20031030L;
9118
9119  private static @Prototype LogicalXorLong_zxy proto = new @Prototype LogicalXorLong_zxy ();
9120
9121  /** Returns the prototype invariant for LogicalXorLong_zxy */
9122  public static @Prototype LogicalXorLong_zxy get_proto() {
9123    return proto;
9124  }
9125
9126  /** instantiate an invariant on the specified slice */
9127  @Override
9128  protected LogicalXorLong_zxy instantiate_dyn(@Prototype LogicalXorLong_zxy this, PptSlice slice) {
9129    return new LogicalXorLong_zxy (slice);
9130  }
9131
9132  private LogicalXorLong_zxy (PptSlice slice) {
9133    super(slice);
9134  }
9135
9136  public @Prototype LogicalXorLong_zxy () {
9137    super();
9138  }
9139
9140  private static String[] method_name = new String[] {"org.plumelib.util.MathPlume.logicalXor(", ", ", ")"};
9141
9142  @Override
9143  public String[] get_method_name(@GuardSatisfied LogicalXorLong_zxy this) {
9144    return method_name;
9145  }
9146
9147  private static int function_id = -1;
9148
9149  @Override
9150  public int get_function_id() {
9151    return function_id;
9152  }
9153
9154  @Override
9155  public void set_function_id(int function_id) {
9156    assert LogicalXorLong_zxy.function_id == -1;
9157    LogicalXorLong_zxy.function_id = function_id;
9158  }
9159
9160  private static int var_order = 3;
9161
9162  @Override
9163  public int get_var_order(@GuardSatisfied LogicalXorLong_zxy this) {
9164    return var_order;
9165  }
9166
9167  @Pure
9168  @Override
9169  public boolean is_symmetric() {
9170
9171      return true;
9172  }
9173
9174  @Override
9175
9176  public long func(long x, long y) {
9177
9178      if ((x < 0) || (x > 1)) {
9179        throw new ArithmeticException("arg1 (" + x + ") is not boolean ");
9180      }
9181      if ((y < 0) || (y > 1)) {
9182        throw new ArithmeticException("arg2 (" + y + ") is not boolean ");
9183      }
9184
9185    return (((x != 0) ^ ( y != 0)) ? 1 : 0);
9186  }
9187
9188  @Override
9189  public InvariantStatus check_modified(long x, long y,
9190                                      long z, int count) {
9191    return check_ordered(z, x, y, count);
9192  }
9193
9194  @Override
9195  public InvariantStatus add_modified(long x, long y,
9196                                      long z, int count) {
9197    if (Debug.logDetail()) {
9198      log("result=%s, arg1=%s, arg2=%s", z, x, y);
9199    }
9200    return add_ordered(z, x, y, count);
9201  }
9202
9203  @Pure
9204  @Override
9205  public boolean isLogicalXor() {
9206    return true;
9207  }
9208
9209  /** Returns a list of non-instantiating suppressions for this invariant. */
9210  @Pure
9211  @Override
9212  public @Nullable NISuppressionSet get_ni_suppressions() {
9213    if (NIS.dkconfig_enabled && dkconfig_enabled) {
9214      return suppressions;
9215    } else {
9216      return null;
9217    }
9218  }
9219
9220  /** definition of this invariant (the suppressee) */
9221  private static NISuppressee suppressee = new NISuppressee(LogicalXorLong_zxy.class, 3);
9222
9223  // suppressor definitions (used below)
9224  private static NISuppressor result_eq_arg1 =
9225      new NISuppressor(2, 0, IntEqual.class);
9226  private static NISuppressor result_eq_arg2 =
9227      new NISuppressor(2, 1, IntEqual.class);
9228  private static NISuppressor arg1_eq_arg2 =
9229      new NISuppressor(0, 1, IntEqual.class);
9230
9231  private static NISuppressor result_lt_arg1 =
9232      new NISuppressor(2, 0, IntLessThan.class);
9233  private static NISuppressor result_lt_arg2 =
9234      new NISuppressor(2, 1, IntLessThan.class);
9235  private static NISuppressor arg1_lt_arg2 =
9236      new NISuppressor(0, 1, IntLessThan.class);
9237  private static NISuppressor arg2_lt_arg1 =
9238      new NISuppressor(1, 0, IntLessThan.class);
9239
9240  private static NISuppressor result_le_arg1 =
9241      new NISuppressor(2, 0, IntLessEqual.class);
9242  private static NISuppressor result_le_arg2 =
9243      new NISuppressor(2, 1, IntLessEqual.class);
9244  private static NISuppressor arg1_le_arg2 =
9245      new NISuppressor(0, 1, IntLessEqual.class);
9246  private static NISuppressor arg2_le_arg1 =
9247      new NISuppressor(1, 0, IntLessEqual.class);
9248
9249  private static NISuppressor result_track0_arg1 =
9250      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
9251  private static NISuppressor result_track0_arg2 =
9252      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
9253  private static NISuppressor arg1_track0_arg2 =
9254      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
9255  private static NISuppressor arg1_track0_result =
9256      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
9257  private static NISuppressor arg2_track0_result =
9258      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
9259  private static NISuppressor arg2_track0_arg1 =
9260      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
9261
9262  private static NISuppressor result_eq_1 =
9263      new NISuppressor(2, RangeInt.EqualOne.class);
9264  private static NISuppressor arg1_eq_1 =
9265      new NISuppressor(0, RangeInt.EqualOne.class);
9266  private static NISuppressor arg2_eq_1 =
9267      new NISuppressor(1, RangeInt.EqualOne.class);
9268
9269  private static NISuppressor result_eq_0 =
9270      new NISuppressor(2, RangeInt.EqualZero.class);
9271  private static NISuppressor arg1_eq_0 =
9272      new NISuppressor(0, RangeInt.EqualZero.class);
9273  private static NISuppressor arg2_eq_0 =
9274      new NISuppressor(1, RangeInt.EqualZero.class);
9275
9276  private static NISuppressor result_ne_0 =
9277      new NISuppressor(2, NonZero.class);
9278  private static NISuppressor arg1_ne_0 =
9279      new NISuppressor(0, NonZero.class);
9280  private static NISuppressor arg2_ne_0 =
9281      new NISuppressor(1, NonZero.class);
9282
9283  private static NISuppressor result_ge_0 =
9284      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
9285  private static NISuppressor arg1_ge_0 =
9286      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
9287  private static NISuppressor arg2_ge_0 =
9288      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
9289
9290  private static NISuppressor result_ge_64 =
9291      new NISuppressor(2, RangeInt.GreaterEqual64.class);
9292  private static NISuppressor arg1_ge_64 =
9293      new NISuppressor(0, RangeInt.GreaterEqual64.class);
9294  private static NISuppressor arg2_ge_64 =
9295      new NISuppressor(1, RangeInt.GreaterEqual64.class);
9296
9297  private static NISuppressor result_boolean =
9298      new NISuppressor(2, RangeInt.BooleanVal.class);
9299  private static NISuppressor arg1_boolean =
9300      new NISuppressor(0, RangeInt.BooleanVal.class);
9301  private static NISuppressor arg2_boolean =
9302      new NISuppressor(1, RangeInt.BooleanVal.class);
9303
9304  private static NISuppressor result_even =
9305      new NISuppressor(2, RangeInt.Even.class);
9306  private static NISuppressor arg1_even =
9307      new NISuppressor(0, RangeInt.Even.class);
9308  private static NISuppressor arg2_even =
9309      new NISuppressor(1, RangeInt.Even.class);
9310
9311  private static NISuppressor result_power2 =
9312      new NISuppressor(2, RangeInt.PowerOfTwo.class);
9313  private static NISuppressor arg1_power2 =
9314      new NISuppressor(0, RangeInt.PowerOfTwo.class);
9315  private static NISuppressor arg2_power2 =
9316      new NISuppressor(1, RangeInt.PowerOfTwo.class);
9317
9318  private static NISuppressor result_and0_arg1 =
9319      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
9320  private static NISuppressor result_and0_arg2 =
9321      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
9322  private static NISuppressor arg1_and0_arg2 =
9323      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
9324
9325  // The arguments to bitwise subset are backwards from what one
9326  // might expect.  The second argument is a subset of the first
9327  // argument
9328  private static NISuppressor arg1_bw_subset_arg2 =
9329      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
9330  private static NISuppressor arg2_bw_subset_arg1 =
9331      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
9332
9333  private static NISuppressor result_shift0_arg1 =
9334      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
9335  private static NISuppressor result_shift0_arg2 =
9336      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
9337  private static NISuppressor arg1_shift0_arg2 =
9338      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
9339
9340  private static NISuppressor arg2_divides_arg1 =
9341      new NISuppressor(0, 1, NumericInt.Divides.class);
9342  private static NISuppressor arg1_divides_arg2 =
9343      new NISuppressor(1, 0, NumericInt.Divides.class);
9344
9345  private static NISuppressor arg2_valid_shift =
9346      new NISuppressor(1, RangeInt.Bound0_63.class);
9347
9348    private static NISuppressionSet suppressions =
9349        new NISuppressionSet(
9350          new NISuppression[] {
9351
9352            // (r == 0) && (x == y) && (x boolean) ==> r = x ^ y
9353            new NISuppression(arg1_eq_arg2, arg1_boolean, result_eq_0,
9354                               suppressee),
9355
9356            // (r == x) && (y == 0) && (z boolean) ==> r = x ^ y
9357            new NISuppression(result_eq_arg1, result_boolean, arg2_eq_0,
9358                               suppressee),
9359
9360            // (r == y) && (x == 0) && (z boolean)==> r = x ^ y
9361            new NISuppression(result_eq_arg2, result_boolean, arg1_eq_0,
9362                               suppressee),
9363
9364          });
9365
9366  // Create a suppression factory for functionBinary
9367
9368}
9369
9370  // #define EQUALITY_SUPPRESS 1
9371
9372  // default is that it is not this function, overriden in the subclass
9373  @Pure
9374  public boolean isBitwiseOr() {
9375    return false;
9376  }
9377
9378/**
9379 * Represents the invariant {@code x = BitwiseOr(y, z)} over three long
9380 * scalars. 
9381 */
9382public static class BitwiseOrLong_xyz extends FunctionBinary {
9383  // We are Serializable, so we specify a version to allow changes to
9384  // method signatures without breaking serialization.  If you add or
9385  // remove fields, you should change this number to the current date.
9386  static final long serialVersionUID = 20031030L;
9387
9388  private static @Prototype BitwiseOrLong_xyz proto = new @Prototype BitwiseOrLong_xyz ();
9389
9390  /** Returns the prototype invariant for BitwiseOrLong_xyz */
9391  public static @Prototype BitwiseOrLong_xyz get_proto() {
9392    return proto;
9393  }
9394
9395  /** instantiate an invariant on the specified slice */
9396  @Override
9397  protected BitwiseOrLong_xyz instantiate_dyn(@Prototype BitwiseOrLong_xyz this, PptSlice slice) {
9398    return new BitwiseOrLong_xyz (slice);
9399  }
9400
9401  private BitwiseOrLong_xyz (PptSlice slice) {
9402    super(slice);
9403  }
9404
9405  public @Prototype BitwiseOrLong_xyz () {
9406    super();
9407  }
9408
9409  private static String[] method_name = new String[] {"", " | ", ""};
9410
9411  @Override
9412  public String[] get_method_name(@GuardSatisfied BitwiseOrLong_xyz this) {
9413    return method_name;
9414  }
9415
9416  private static int function_id = -1;
9417
9418  @Override
9419  public int get_function_id() {
9420    return function_id;
9421  }
9422
9423  @Override
9424  public void set_function_id(int function_id) {
9425    assert BitwiseOrLong_xyz.function_id == -1;
9426    BitwiseOrLong_xyz.function_id = function_id;
9427  }
9428
9429  private static int var_order = 1;
9430
9431  @Override
9432  public int get_var_order(@GuardSatisfied BitwiseOrLong_xyz this) {
9433    return var_order;
9434  }
9435
9436  @Pure
9437  @Override
9438  public boolean is_symmetric() {
9439
9440      return true;
9441  }
9442
9443  @Override
9444
9445  public long func(long y, long z) {
9446
9447    return (y | z);
9448  }
9449
9450  @Override
9451  public InvariantStatus check_modified(long x, long y,
9452                                      long z, int count) {
9453    return check_ordered(x, y, z, count);
9454  }
9455
9456  @Override
9457  public InvariantStatus add_modified(long x, long y,
9458                                      long z, int count) {
9459    if (Debug.logDetail()) {
9460      log("result=%s, arg1=%s, arg2=%s", x, y, z);
9461    }
9462    return add_ordered(x, y, z, count);
9463  }
9464
9465  @Pure
9466  @Override
9467  public boolean isBitwiseOr() {
9468    return true;
9469  }
9470
9471  /** Returns a list of non-instantiating suppressions for this invariant. */
9472  @Pure
9473  @Override
9474  public @Nullable NISuppressionSet get_ni_suppressions() {
9475    if (NIS.dkconfig_enabled && dkconfig_enabled) {
9476      return suppressions;
9477    } else {
9478      return null;
9479    }
9480  }
9481
9482  /** definition of this invariant (the suppressee) */
9483  private static NISuppressee suppressee = new NISuppressee(BitwiseOrLong_xyz.class, 3);
9484
9485  // suppressor definitions (used below)
9486  private static NISuppressor result_eq_arg1 =
9487      new NISuppressor(0, 1, IntEqual.class);
9488  private static NISuppressor result_eq_arg2 =
9489      new NISuppressor(0, 2, IntEqual.class);
9490  private static NISuppressor arg1_eq_arg2 =
9491      new NISuppressor(1, 2, IntEqual.class);
9492
9493  private static NISuppressor result_lt_arg1 =
9494      new NISuppressor(0, 1, IntLessThan.class);
9495  private static NISuppressor result_lt_arg2 =
9496      new NISuppressor(0, 2, IntLessThan.class);
9497  private static NISuppressor arg1_lt_arg2 =
9498      new NISuppressor(1, 2, IntLessThan.class);
9499  private static NISuppressor arg2_lt_arg1 =
9500      new NISuppressor(2, 1, IntLessThan.class);
9501
9502  private static NISuppressor result_le_arg1 =
9503      new NISuppressor(0, 1, IntLessEqual.class);
9504  private static NISuppressor result_le_arg2 =
9505      new NISuppressor(0, 2, IntLessEqual.class);
9506  private static NISuppressor arg1_le_arg2 =
9507      new NISuppressor(1, 2, IntLessEqual.class);
9508  private static NISuppressor arg2_le_arg1 =
9509      new NISuppressor(2, 1, IntLessEqual.class);
9510
9511  private static NISuppressor result_track0_arg1 =
9512      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
9513  private static NISuppressor result_track0_arg2 =
9514      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
9515  private static NISuppressor arg1_track0_arg2 =
9516      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
9517  private static NISuppressor arg1_track0_result =
9518      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
9519  private static NISuppressor arg2_track0_result =
9520      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
9521  private static NISuppressor arg2_track0_arg1 =
9522      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
9523
9524  private static NISuppressor result_eq_1 =
9525      new NISuppressor(0, RangeInt.EqualOne.class);
9526  private static NISuppressor arg1_eq_1 =
9527      new NISuppressor(1, RangeInt.EqualOne.class);
9528  private static NISuppressor arg2_eq_1 =
9529      new NISuppressor(2, RangeInt.EqualOne.class);
9530
9531  private static NISuppressor result_eq_0 =
9532      new NISuppressor(0, RangeInt.EqualZero.class);
9533  private static NISuppressor arg1_eq_0 =
9534      new NISuppressor(1, RangeInt.EqualZero.class);
9535  private static NISuppressor arg2_eq_0 =
9536      new NISuppressor(2, RangeInt.EqualZero.class);
9537
9538  private static NISuppressor result_ne_0 =
9539      new NISuppressor(0, NonZero.class);
9540  private static NISuppressor arg1_ne_0 =
9541      new NISuppressor(1, NonZero.class);
9542  private static NISuppressor arg2_ne_0 =
9543      new NISuppressor(2, NonZero.class);
9544
9545  private static NISuppressor result_ge_0 =
9546      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
9547  private static NISuppressor arg1_ge_0 =
9548      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
9549  private static NISuppressor arg2_ge_0 =
9550      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
9551
9552  private static NISuppressor result_ge_64 =
9553      new NISuppressor(0, RangeInt.GreaterEqual64.class);
9554  private static NISuppressor arg1_ge_64 =
9555      new NISuppressor(1, RangeInt.GreaterEqual64.class);
9556  private static NISuppressor arg2_ge_64 =
9557      new NISuppressor(2, RangeInt.GreaterEqual64.class);
9558
9559  private static NISuppressor result_boolean =
9560      new NISuppressor(0, RangeInt.BooleanVal.class);
9561  private static NISuppressor arg1_boolean =
9562      new NISuppressor(1, RangeInt.BooleanVal.class);
9563  private static NISuppressor arg2_boolean =
9564      new NISuppressor(2, RangeInt.BooleanVal.class);
9565
9566  private static NISuppressor result_even =
9567      new NISuppressor(0, RangeInt.Even.class);
9568  private static NISuppressor arg1_even =
9569      new NISuppressor(1, RangeInt.Even.class);
9570  private static NISuppressor arg2_even =
9571      new NISuppressor(2, RangeInt.Even.class);
9572
9573  private static NISuppressor result_power2 =
9574      new NISuppressor(0, RangeInt.PowerOfTwo.class);
9575  private static NISuppressor arg1_power2 =
9576      new NISuppressor(1, RangeInt.PowerOfTwo.class);
9577  private static NISuppressor arg2_power2 =
9578      new NISuppressor(2, RangeInt.PowerOfTwo.class);
9579
9580  private static NISuppressor result_and0_arg1 =
9581      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
9582  private static NISuppressor result_and0_arg2 =
9583      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
9584  private static NISuppressor arg1_and0_arg2 =
9585      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
9586
9587  // The arguments to bitwise subset are backwards from what one
9588  // might expect.  The second argument is a subset of the first
9589  // argument
9590  private static NISuppressor arg1_bw_subset_arg2 =
9591      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
9592  private static NISuppressor arg2_bw_subset_arg1 =
9593      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
9594
9595  private static NISuppressor result_shift0_arg1 =
9596      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
9597  private static NISuppressor result_shift0_arg2 =
9598      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
9599  private static NISuppressor arg1_shift0_arg2 =
9600      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
9601
9602  private static NISuppressor arg2_divides_arg1 =
9603      new NISuppressor(1, 2, NumericInt.Divides.class);
9604  private static NISuppressor arg1_divides_arg2 =
9605      new NISuppressor(2, 1, NumericInt.Divides.class);
9606
9607  private static NISuppressor arg2_valid_shift =
9608      new NISuppressor(2, RangeInt.Bound0_63.class);
9609
9610    private static NISuppressionSet suppressions =
9611        new NISuppressionSet(
9612          new NISuppression[] {
9613
9614            // (r == y) && (z bitwise subset y)
9615            new NISuppression(result_eq_arg1, arg2_bw_subset_arg1, suppressee),
9616
9617            // (r == z) && (y bitwise subset z)
9618            new NISuppression(result_eq_arg2, arg1_bw_subset_arg2, suppressee),
9619
9620            // All of the below are subsummed by the two above
9621            // (r == y) && (y == z) ==> r = y | z
9622            // new NISuppression (result_eq_arg1, arg1_eq_arg2, suppressee),
9623
9624            // (r == y) && (z == 0) ==> r = y | z
9625            // new NISuppression (result_eq_arg1, arg2_eq_0, suppressee),
9626
9627            // (r == z) && (y == 0) ==> r = y | z
9628            // new NISuppression (result_eq_arg2, arg1_eq_0, suppressee),
9629
9630            // (r == 1) && (y == 1) && (z boolean)
9631            // new NISuppression (result_eq_1, arg1_eq_1, arg2_boolean, suppressee),
9632
9633            // (r == 1) && (z == 1) && (y boolean)
9634            // new NISuppression (result_eq_1, arg2_eq_1, arg1_boolean, suppressee),
9635
9636          });
9637
9638  // Create a suppression factory for functionBinary
9639
9640}
9641
9642/**
9643 * Represents the invariant {@code y = BitwiseOr(x, z)} over three long
9644 * scalars. 
9645 */
9646public static class BitwiseOrLong_yxz extends FunctionBinary {
9647  // We are Serializable, so we specify a version to allow changes to
9648  // method signatures without breaking serialization.  If you add or
9649  // remove fields, you should change this number to the current date.
9650  static final long serialVersionUID = 20031030L;
9651
9652  private static @Prototype BitwiseOrLong_yxz proto = new @Prototype BitwiseOrLong_yxz ();
9653
9654  /** Returns the prototype invariant for BitwiseOrLong_yxz */
9655  public static @Prototype BitwiseOrLong_yxz get_proto() {
9656    return proto;
9657  }
9658
9659  /** instantiate an invariant on the specified slice */
9660  @Override
9661  protected BitwiseOrLong_yxz instantiate_dyn(@Prototype BitwiseOrLong_yxz this, PptSlice slice) {
9662    return new BitwiseOrLong_yxz (slice);
9663  }
9664
9665  private BitwiseOrLong_yxz (PptSlice slice) {
9666    super(slice);
9667  }
9668
9669  public @Prototype BitwiseOrLong_yxz () {
9670    super();
9671  }
9672
9673  private static String[] method_name = new String[] {"", " | ", ""};
9674
9675  @Override
9676  public String[] get_method_name(@GuardSatisfied BitwiseOrLong_yxz this) {
9677    return method_name;
9678  }
9679
9680  private static int function_id = -1;
9681
9682  @Override
9683  public int get_function_id() {
9684    return function_id;
9685  }
9686
9687  @Override
9688  public void set_function_id(int function_id) {
9689    assert BitwiseOrLong_yxz.function_id == -1;
9690    BitwiseOrLong_yxz.function_id = function_id;
9691  }
9692
9693  private static int var_order = 2;
9694
9695  @Override
9696  public int get_var_order(@GuardSatisfied BitwiseOrLong_yxz this) {
9697    return var_order;
9698  }
9699
9700  @Pure
9701  @Override
9702  public boolean is_symmetric() {
9703
9704      return true;
9705  }
9706
9707  @Override
9708
9709  public long func(long x, long z) {
9710
9711    return (x | z);
9712  }
9713
9714  @Override
9715  public InvariantStatus check_modified(long x, long y,
9716                                      long z, int count) {
9717    return check_ordered(y, x, z, count);
9718  }
9719
9720  @Override
9721  public InvariantStatus add_modified(long x, long y,
9722                                      long z, int count) {
9723    if (Debug.logDetail()) {
9724      log("result=%s, arg1=%s, arg2=%s", y, x, z);
9725    }
9726    return add_ordered(y, x, z, count);
9727  }
9728
9729  @Pure
9730  @Override
9731  public boolean isBitwiseOr() {
9732    return true;
9733  }
9734
9735  /** Returns a list of non-instantiating suppressions for this invariant. */
9736  @Pure
9737  @Override
9738  public @Nullable NISuppressionSet get_ni_suppressions() {
9739    if (NIS.dkconfig_enabled && dkconfig_enabled) {
9740      return suppressions;
9741    } else {
9742      return null;
9743    }
9744  }
9745
9746  /** definition of this invariant (the suppressee) */
9747  private static NISuppressee suppressee = new NISuppressee(BitwiseOrLong_yxz.class, 3);
9748
9749  // suppressor definitions (used below)
9750  private static NISuppressor result_eq_arg1 =
9751      new NISuppressor(1, 0, IntEqual.class);
9752  private static NISuppressor result_eq_arg2 =
9753      new NISuppressor(1, 2, IntEqual.class);
9754  private static NISuppressor arg1_eq_arg2 =
9755      new NISuppressor(0, 2, IntEqual.class);
9756
9757  private static NISuppressor result_lt_arg1 =
9758      new NISuppressor(1, 0, IntLessThan.class);
9759  private static NISuppressor result_lt_arg2 =
9760      new NISuppressor(1, 2, IntLessThan.class);
9761  private static NISuppressor arg1_lt_arg2 =
9762      new NISuppressor(0, 2, IntLessThan.class);
9763  private static NISuppressor arg2_lt_arg1 =
9764      new NISuppressor(2, 0, IntLessThan.class);
9765
9766  private static NISuppressor result_le_arg1 =
9767      new NISuppressor(1, 0, IntLessEqual.class);
9768  private static NISuppressor result_le_arg2 =
9769      new NISuppressor(1, 2, IntLessEqual.class);
9770  private static NISuppressor arg1_le_arg2 =
9771      new NISuppressor(0, 2, IntLessEqual.class);
9772  private static NISuppressor arg2_le_arg1 =
9773      new NISuppressor(2, 0, IntLessEqual.class);
9774
9775  private static NISuppressor result_track0_arg1 =
9776      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
9777  private static NISuppressor result_track0_arg2 =
9778      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
9779  private static NISuppressor arg1_track0_arg2 =
9780      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
9781  private static NISuppressor arg1_track0_result =
9782      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
9783  private static NISuppressor arg2_track0_result =
9784      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
9785  private static NISuppressor arg2_track0_arg1 =
9786      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
9787
9788  private static NISuppressor result_eq_1 =
9789      new NISuppressor(1, RangeInt.EqualOne.class);
9790  private static NISuppressor arg1_eq_1 =
9791      new NISuppressor(0, RangeInt.EqualOne.class);
9792  private static NISuppressor arg2_eq_1 =
9793      new NISuppressor(2, RangeInt.EqualOne.class);
9794
9795  private static NISuppressor result_eq_0 =
9796      new NISuppressor(1, RangeInt.EqualZero.class);
9797  private static NISuppressor arg1_eq_0 =
9798      new NISuppressor(0, RangeInt.EqualZero.class);
9799  private static NISuppressor arg2_eq_0 =
9800      new NISuppressor(2, RangeInt.EqualZero.class);
9801
9802  private static NISuppressor result_ne_0 =
9803      new NISuppressor(1, NonZero.class);
9804  private static NISuppressor arg1_ne_0 =
9805      new NISuppressor(0, NonZero.class);
9806  private static NISuppressor arg2_ne_0 =
9807      new NISuppressor(2, NonZero.class);
9808
9809  private static NISuppressor result_ge_0 =
9810      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
9811  private static NISuppressor arg1_ge_0 =
9812      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
9813  private static NISuppressor arg2_ge_0 =
9814      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
9815
9816  private static NISuppressor result_ge_64 =
9817      new NISuppressor(1, RangeInt.GreaterEqual64.class);
9818  private static NISuppressor arg1_ge_64 =
9819      new NISuppressor(0, RangeInt.GreaterEqual64.class);
9820  private static NISuppressor arg2_ge_64 =
9821      new NISuppressor(2, RangeInt.GreaterEqual64.class);
9822
9823  private static NISuppressor result_boolean =
9824      new NISuppressor(1, RangeInt.BooleanVal.class);
9825  private static NISuppressor arg1_boolean =
9826      new NISuppressor(0, RangeInt.BooleanVal.class);
9827  private static NISuppressor arg2_boolean =
9828      new NISuppressor(2, RangeInt.BooleanVal.class);
9829
9830  private static NISuppressor result_even =
9831      new NISuppressor(1, RangeInt.Even.class);
9832  private static NISuppressor arg1_even =
9833      new NISuppressor(0, RangeInt.Even.class);
9834  private static NISuppressor arg2_even =
9835      new NISuppressor(2, RangeInt.Even.class);
9836
9837  private static NISuppressor result_power2 =
9838      new NISuppressor(1, RangeInt.PowerOfTwo.class);
9839  private static NISuppressor arg1_power2 =
9840      new NISuppressor(0, RangeInt.PowerOfTwo.class);
9841  private static NISuppressor arg2_power2 =
9842      new NISuppressor(2, RangeInt.PowerOfTwo.class);
9843
9844  private static NISuppressor result_and0_arg1 =
9845      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
9846  private static NISuppressor result_and0_arg2 =
9847      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
9848  private static NISuppressor arg1_and0_arg2 =
9849      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
9850
9851  // The arguments to bitwise subset are backwards from what one
9852  // might expect.  The second argument is a subset of the first
9853  // argument
9854  private static NISuppressor arg1_bw_subset_arg2 =
9855      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
9856  private static NISuppressor arg2_bw_subset_arg1 =
9857      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
9858
9859  private static NISuppressor result_shift0_arg1 =
9860      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
9861  private static NISuppressor result_shift0_arg2 =
9862      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
9863  private static NISuppressor arg1_shift0_arg2 =
9864      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
9865
9866  private static NISuppressor arg2_divides_arg1 =
9867      new NISuppressor(0, 2, NumericInt.Divides.class);
9868  private static NISuppressor arg1_divides_arg2 =
9869      new NISuppressor(2, 0, NumericInt.Divides.class);
9870
9871  private static NISuppressor arg2_valid_shift =
9872      new NISuppressor(2, RangeInt.Bound0_63.class);
9873
9874    private static NISuppressionSet suppressions =
9875        new NISuppressionSet(
9876          new NISuppression[] {
9877
9878            // (r == x) && (z bitwise subset x)
9879            new NISuppression(result_eq_arg1, arg2_bw_subset_arg1, suppressee),
9880
9881            // (r == z) && (x bitwise subset z)
9882            new NISuppression(result_eq_arg2, arg1_bw_subset_arg2, suppressee),
9883
9884            // All of the below are subsummed by the two above
9885            // (r == x) && (x == z) ==> r = x | z
9886            // new NISuppression (result_eq_arg1, arg1_eq_arg2, suppressee),
9887
9888            // (r == x) && (z == 0) ==> r = x | z
9889            // new NISuppression (result_eq_arg1, arg2_eq_0, suppressee),
9890
9891            // (r == z) && (x == 0) ==> r = x | z
9892            // new NISuppression (result_eq_arg2, arg1_eq_0, suppressee),
9893
9894            // (r == 1) && (x == 1) && (z boolean)
9895            // new NISuppression (result_eq_1, arg1_eq_1, arg2_boolean, suppressee),
9896
9897            // (r == 1) && (z == 1) && (x boolean)
9898            // new NISuppression (result_eq_1, arg2_eq_1, arg1_boolean, suppressee),
9899
9900          });
9901
9902  // Create a suppression factory for functionBinary
9903
9904}
9905
9906/**
9907 * Represents the invariant {@code z = BitwiseOr(x, y)} over three long
9908 * scalars. 
9909 */
9910public static class BitwiseOrLong_zxy extends FunctionBinary {
9911  // We are Serializable, so we specify a version to allow changes to
9912  // method signatures without breaking serialization.  If you add or
9913  // remove fields, you should change this number to the current date.
9914  static final long serialVersionUID = 20031030L;
9915
9916  private static @Prototype BitwiseOrLong_zxy proto = new @Prototype BitwiseOrLong_zxy ();
9917
9918  /** Returns the prototype invariant for BitwiseOrLong_zxy */
9919  public static @Prototype BitwiseOrLong_zxy get_proto() {
9920    return proto;
9921  }
9922
9923  /** instantiate an invariant on the specified slice */
9924  @Override
9925  protected BitwiseOrLong_zxy instantiate_dyn(@Prototype BitwiseOrLong_zxy this, PptSlice slice) {
9926    return new BitwiseOrLong_zxy (slice);
9927  }
9928
9929  private BitwiseOrLong_zxy (PptSlice slice) {
9930    super(slice);
9931  }
9932
9933  public @Prototype BitwiseOrLong_zxy () {
9934    super();
9935  }
9936
9937  private static String[] method_name = new String[] {"", " | ", ""};
9938
9939  @Override
9940  public String[] get_method_name(@GuardSatisfied BitwiseOrLong_zxy this) {
9941    return method_name;
9942  }
9943
9944  private static int function_id = -1;
9945
9946  @Override
9947  public int get_function_id() {
9948    return function_id;
9949  }
9950
9951  @Override
9952  public void set_function_id(int function_id) {
9953    assert BitwiseOrLong_zxy.function_id == -1;
9954    BitwiseOrLong_zxy.function_id = function_id;
9955  }
9956
9957  private static int var_order = 3;
9958
9959  @Override
9960  public int get_var_order(@GuardSatisfied BitwiseOrLong_zxy this) {
9961    return var_order;
9962  }
9963
9964  @Pure
9965  @Override
9966  public boolean is_symmetric() {
9967
9968      return true;
9969  }
9970
9971  @Override
9972
9973  public long func(long x, long y) {
9974
9975    return (x | y);
9976  }
9977
9978  @Override
9979  public InvariantStatus check_modified(long x, long y,
9980                                      long z, int count) {
9981    return check_ordered(z, x, y, count);
9982  }
9983
9984  @Override
9985  public InvariantStatus add_modified(long x, long y,
9986                                      long z, int count) {
9987    if (Debug.logDetail()) {
9988      log("result=%s, arg1=%s, arg2=%s", z, x, y);
9989    }
9990    return add_ordered(z, x, y, count);
9991  }
9992
9993  @Pure
9994  @Override
9995  public boolean isBitwiseOr() {
9996    return true;
9997  }
9998
9999  /** Returns a list of non-instantiating suppressions for this invariant. */
10000  @Pure
10001  @Override
10002  public @Nullable NISuppressionSet get_ni_suppressions() {
10003    if (NIS.dkconfig_enabled && dkconfig_enabled) {
10004      return suppressions;
10005    } else {
10006      return null;
10007    }
10008  }
10009
10010  /** definition of this invariant (the suppressee) */
10011  private static NISuppressee suppressee = new NISuppressee(BitwiseOrLong_zxy.class, 3);
10012
10013  // suppressor definitions (used below)
10014  private static NISuppressor result_eq_arg1 =
10015      new NISuppressor(2, 0, IntEqual.class);
10016  private static NISuppressor result_eq_arg2 =
10017      new NISuppressor(2, 1, IntEqual.class);
10018  private static NISuppressor arg1_eq_arg2 =
10019      new NISuppressor(0, 1, IntEqual.class);
10020
10021  private static NISuppressor result_lt_arg1 =
10022      new NISuppressor(2, 0, IntLessThan.class);
10023  private static NISuppressor result_lt_arg2 =
10024      new NISuppressor(2, 1, IntLessThan.class);
10025  private static NISuppressor arg1_lt_arg2 =
10026      new NISuppressor(0, 1, IntLessThan.class);
10027  private static NISuppressor arg2_lt_arg1 =
10028      new NISuppressor(1, 0, IntLessThan.class);
10029
10030  private static NISuppressor result_le_arg1 =
10031      new NISuppressor(2, 0, IntLessEqual.class);
10032  private static NISuppressor result_le_arg2 =
10033      new NISuppressor(2, 1, IntLessEqual.class);
10034  private static NISuppressor arg1_le_arg2 =
10035      new NISuppressor(0, 1, IntLessEqual.class);
10036  private static NISuppressor arg2_le_arg1 =
10037      new NISuppressor(1, 0, IntLessEqual.class);
10038
10039  private static NISuppressor result_track0_arg1 =
10040      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
10041  private static NISuppressor result_track0_arg2 =
10042      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
10043  private static NISuppressor arg1_track0_arg2 =
10044      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
10045  private static NISuppressor arg1_track0_result =
10046      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
10047  private static NISuppressor arg2_track0_result =
10048      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
10049  private static NISuppressor arg2_track0_arg1 =
10050      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
10051
10052  private static NISuppressor result_eq_1 =
10053      new NISuppressor(2, RangeInt.EqualOne.class);
10054  private static NISuppressor arg1_eq_1 =
10055      new NISuppressor(0, RangeInt.EqualOne.class);
10056  private static NISuppressor arg2_eq_1 =
10057      new NISuppressor(1, RangeInt.EqualOne.class);
10058
10059  private static NISuppressor result_eq_0 =
10060      new NISuppressor(2, RangeInt.EqualZero.class);
10061  private static NISuppressor arg1_eq_0 =
10062      new NISuppressor(0, RangeInt.EqualZero.class);
10063  private static NISuppressor arg2_eq_0 =
10064      new NISuppressor(1, RangeInt.EqualZero.class);
10065
10066  private static NISuppressor result_ne_0 =
10067      new NISuppressor(2, NonZero.class);
10068  private static NISuppressor arg1_ne_0 =
10069      new NISuppressor(0, NonZero.class);
10070  private static NISuppressor arg2_ne_0 =
10071      new NISuppressor(1, NonZero.class);
10072
10073  private static NISuppressor result_ge_0 =
10074      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
10075  private static NISuppressor arg1_ge_0 =
10076      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
10077  private static NISuppressor arg2_ge_0 =
10078      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
10079
10080  private static NISuppressor result_ge_64 =
10081      new NISuppressor(2, RangeInt.GreaterEqual64.class);
10082  private static NISuppressor arg1_ge_64 =
10083      new NISuppressor(0, RangeInt.GreaterEqual64.class);
10084  private static NISuppressor arg2_ge_64 =
10085      new NISuppressor(1, RangeInt.GreaterEqual64.class);
10086
10087  private static NISuppressor result_boolean =
10088      new NISuppressor(2, RangeInt.BooleanVal.class);
10089  private static NISuppressor arg1_boolean =
10090      new NISuppressor(0, RangeInt.BooleanVal.class);
10091  private static NISuppressor arg2_boolean =
10092      new NISuppressor(1, RangeInt.BooleanVal.class);
10093
10094  private static NISuppressor result_even =
10095      new NISuppressor(2, RangeInt.Even.class);
10096  private static NISuppressor arg1_even =
10097      new NISuppressor(0, RangeInt.Even.class);
10098  private static NISuppressor arg2_even =
10099      new NISuppressor(1, RangeInt.Even.class);
10100
10101  private static NISuppressor result_power2 =
10102      new NISuppressor(2, RangeInt.PowerOfTwo.class);
10103  private static NISuppressor arg1_power2 =
10104      new NISuppressor(0, RangeInt.PowerOfTwo.class);
10105  private static NISuppressor arg2_power2 =
10106      new NISuppressor(1, RangeInt.PowerOfTwo.class);
10107
10108  private static NISuppressor result_and0_arg1 =
10109      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
10110  private static NISuppressor result_and0_arg2 =
10111      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
10112  private static NISuppressor arg1_and0_arg2 =
10113      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
10114
10115  // The arguments to bitwise subset are backwards from what one
10116  // might expect.  The second argument is a subset of the first
10117  // argument
10118  private static NISuppressor arg1_bw_subset_arg2 =
10119      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
10120  private static NISuppressor arg2_bw_subset_arg1 =
10121      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
10122
10123  private static NISuppressor result_shift0_arg1 =
10124      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
10125  private static NISuppressor result_shift0_arg2 =
10126      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
10127  private static NISuppressor arg1_shift0_arg2 =
10128      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
10129
10130  private static NISuppressor arg2_divides_arg1 =
10131      new NISuppressor(0, 1, NumericInt.Divides.class);
10132  private static NISuppressor arg1_divides_arg2 =
10133      new NISuppressor(1, 0, NumericInt.Divides.class);
10134
10135  private static NISuppressor arg2_valid_shift =
10136      new NISuppressor(1, RangeInt.Bound0_63.class);
10137
10138    private static NISuppressionSet suppressions =
10139        new NISuppressionSet(
10140          new NISuppression[] {
10141
10142            // (r == x) && (y bitwise subset x)
10143            new NISuppression(result_eq_arg1, arg2_bw_subset_arg1, suppressee),
10144
10145            // (r == y) && (x bitwise subset y)
10146            new NISuppression(result_eq_arg2, arg1_bw_subset_arg2, suppressee),
10147
10148            // All of the below are subsummed by the two above
10149            // (r == x) && (x == y) ==> r = x | y
10150            // new NISuppression (result_eq_arg1, arg1_eq_arg2, suppressee),
10151
10152            // (r == x) && (y == 0) ==> r = x | y
10153            // new NISuppression (result_eq_arg1, arg2_eq_0, suppressee),
10154
10155            // (r == y) && (x == 0) ==> r = x | y
10156            // new NISuppression (result_eq_arg2, arg1_eq_0, suppressee),
10157
10158            // (r == 1) && (x == 1) && (y boolean)
10159            // new NISuppression (result_eq_1, arg1_eq_1, arg2_boolean, suppressee),
10160
10161            // (r == 1) && (y == 1) && (x boolean)
10162            // new NISuppression (result_eq_1, arg2_eq_1, arg1_boolean, suppressee),
10163
10164          });
10165
10166  // Create a suppression factory for functionBinary
10167
10168}
10169
10170  // default is that it is not this function, overriden in the subclass
10171  @Pure
10172  public boolean isLogicalOr() {
10173    return false;
10174  }
10175
10176/**
10177 * Represents the invariant {@code x = LogicalOr(y, z)} over three long
10178 * scalars. For logical operations, Daikon treats 0 as false and all other values as true.
10179 */
10180public static class LogicalOrLong_xyz extends FunctionBinary {
10181  // We are Serializable, so we specify a version to allow changes to
10182  // method signatures without breaking serialization.  If you add or
10183  // remove fields, you should change this number to the current date.
10184  static final long serialVersionUID = 20031030L;
10185
10186  private static @Prototype LogicalOrLong_xyz proto = new @Prototype LogicalOrLong_xyz ();
10187
10188  /** Returns the prototype invariant for LogicalOrLong_xyz */
10189  public static @Prototype LogicalOrLong_xyz get_proto() {
10190    return proto;
10191  }
10192
10193  /** instantiate an invariant on the specified slice */
10194  @Override
10195  protected LogicalOrLong_xyz instantiate_dyn(@Prototype LogicalOrLong_xyz this, PptSlice slice) {
10196    return new LogicalOrLong_xyz (slice);
10197  }
10198
10199  private LogicalOrLong_xyz (PptSlice slice) {
10200    super(slice);
10201  }
10202
10203  public @Prototype LogicalOrLong_xyz () {
10204    super();
10205  }
10206
10207  private static String[] method_name = new String[] {"", " || ", ""};
10208
10209  @Override
10210  public String[] get_method_name(@GuardSatisfied LogicalOrLong_xyz this) {
10211    return method_name;
10212  }
10213
10214  private static int function_id = -1;
10215
10216  @Override
10217  public int get_function_id() {
10218    return function_id;
10219  }
10220
10221  @Override
10222  public void set_function_id(int function_id) {
10223    assert LogicalOrLong_xyz.function_id == -1;
10224    LogicalOrLong_xyz.function_id = function_id;
10225  }
10226
10227  private static int var_order = 1;
10228
10229  @Override
10230  public int get_var_order(@GuardSatisfied LogicalOrLong_xyz this) {
10231    return var_order;
10232  }
10233
10234  @Pure
10235  @Override
10236  public boolean is_symmetric() {
10237
10238      return true;
10239  }
10240
10241  @Override
10242
10243  public long func(long y, long z) {
10244
10245      if ((y < 0) || (y > 1)) {
10246        throw new ArithmeticException("arg1 (" + y + ") is not boolean ");
10247      }
10248      if ((z < 0) || (z > 1)) {
10249        throw new ArithmeticException("arg2 (" + z + ") is not boolean ");
10250      }
10251
10252    return (((y != 0) || ( z != 0)) ? 1 : 0);
10253  }
10254
10255  @Override
10256  public InvariantStatus check_modified(long x, long y,
10257                                      long z, int count) {
10258    return check_ordered(x, y, z, count);
10259  }
10260
10261  @Override
10262  public InvariantStatus add_modified(long x, long y,
10263                                      long z, int count) {
10264    if (Debug.logDetail()) {
10265      log("result=%s, arg1=%s, arg2=%s", x, y, z);
10266    }
10267    return add_ordered(x, y, z, count);
10268  }
10269
10270  @Pure
10271  @Override
10272  public boolean isLogicalOr() {
10273    return true;
10274  }
10275
10276  /** Returns a list of non-instantiating suppressions for this invariant. */
10277  @Pure
10278  @Override
10279  public @Nullable NISuppressionSet get_ni_suppressions() {
10280    if (NIS.dkconfig_enabled && dkconfig_enabled) {
10281      return suppressions;
10282    } else {
10283      return null;
10284    }
10285  }
10286
10287  /** definition of this invariant (the suppressee) */
10288  private static NISuppressee suppressee = new NISuppressee(LogicalOrLong_xyz.class, 3);
10289
10290  // suppressor definitions (used below)
10291  private static NISuppressor result_eq_arg1 =
10292      new NISuppressor(0, 1, IntEqual.class);
10293  private static NISuppressor result_eq_arg2 =
10294      new NISuppressor(0, 2, IntEqual.class);
10295  private static NISuppressor arg1_eq_arg2 =
10296      new NISuppressor(1, 2, IntEqual.class);
10297
10298  private static NISuppressor result_lt_arg1 =
10299      new NISuppressor(0, 1, IntLessThan.class);
10300  private static NISuppressor result_lt_arg2 =
10301      new NISuppressor(0, 2, IntLessThan.class);
10302  private static NISuppressor arg1_lt_arg2 =
10303      new NISuppressor(1, 2, IntLessThan.class);
10304  private static NISuppressor arg2_lt_arg1 =
10305      new NISuppressor(2, 1, IntLessThan.class);
10306
10307  private static NISuppressor result_le_arg1 =
10308      new NISuppressor(0, 1, IntLessEqual.class);
10309  private static NISuppressor result_le_arg2 =
10310      new NISuppressor(0, 2, IntLessEqual.class);
10311  private static NISuppressor arg1_le_arg2 =
10312      new NISuppressor(1, 2, IntLessEqual.class);
10313  private static NISuppressor arg2_le_arg1 =
10314      new NISuppressor(2, 1, IntLessEqual.class);
10315
10316  private static NISuppressor result_track0_arg1 =
10317      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
10318  private static NISuppressor result_track0_arg2 =
10319      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
10320  private static NISuppressor arg1_track0_arg2 =
10321      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
10322  private static NISuppressor arg1_track0_result =
10323      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
10324  private static NISuppressor arg2_track0_result =
10325      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
10326  private static NISuppressor arg2_track0_arg1 =
10327      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
10328
10329  private static NISuppressor result_eq_1 =
10330      new NISuppressor(0, RangeInt.EqualOne.class);
10331  private static NISuppressor arg1_eq_1 =
10332      new NISuppressor(1, RangeInt.EqualOne.class);
10333  private static NISuppressor arg2_eq_1 =
10334      new NISuppressor(2, RangeInt.EqualOne.class);
10335
10336  private static NISuppressor result_eq_0 =
10337      new NISuppressor(0, RangeInt.EqualZero.class);
10338  private static NISuppressor arg1_eq_0 =
10339      new NISuppressor(1, RangeInt.EqualZero.class);
10340  private static NISuppressor arg2_eq_0 =
10341      new NISuppressor(2, RangeInt.EqualZero.class);
10342
10343  private static NISuppressor result_ne_0 =
10344      new NISuppressor(0, NonZero.class);
10345  private static NISuppressor arg1_ne_0 =
10346      new NISuppressor(1, NonZero.class);
10347  private static NISuppressor arg2_ne_0 =
10348      new NISuppressor(2, NonZero.class);
10349
10350  private static NISuppressor result_ge_0 =
10351      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
10352  private static NISuppressor arg1_ge_0 =
10353      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
10354  private static NISuppressor arg2_ge_0 =
10355      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
10356
10357  private static NISuppressor result_ge_64 =
10358      new NISuppressor(0, RangeInt.GreaterEqual64.class);
10359  private static NISuppressor arg1_ge_64 =
10360      new NISuppressor(1, RangeInt.GreaterEqual64.class);
10361  private static NISuppressor arg2_ge_64 =
10362      new NISuppressor(2, RangeInt.GreaterEqual64.class);
10363
10364  private static NISuppressor result_boolean =
10365      new NISuppressor(0, RangeInt.BooleanVal.class);
10366  private static NISuppressor arg1_boolean =
10367      new NISuppressor(1, RangeInt.BooleanVal.class);
10368  private static NISuppressor arg2_boolean =
10369      new NISuppressor(2, RangeInt.BooleanVal.class);
10370
10371  private static NISuppressor result_even =
10372      new NISuppressor(0, RangeInt.Even.class);
10373  private static NISuppressor arg1_even =
10374      new NISuppressor(1, RangeInt.Even.class);
10375  private static NISuppressor arg2_even =
10376      new NISuppressor(2, RangeInt.Even.class);
10377
10378  private static NISuppressor result_power2 =
10379      new NISuppressor(0, RangeInt.PowerOfTwo.class);
10380  private static NISuppressor arg1_power2 =
10381      new NISuppressor(1, RangeInt.PowerOfTwo.class);
10382  private static NISuppressor arg2_power2 =
10383      new NISuppressor(2, RangeInt.PowerOfTwo.class);
10384
10385  private static NISuppressor result_and0_arg1 =
10386      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
10387  private static NISuppressor result_and0_arg2 =
10388      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
10389  private static NISuppressor arg1_and0_arg2 =
10390      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
10391
10392  // The arguments to bitwise subset are backwards from what one
10393  // might expect.  The second argument is a subset of the first
10394  // argument
10395  private static NISuppressor arg1_bw_subset_arg2 =
10396      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
10397  private static NISuppressor arg2_bw_subset_arg1 =
10398      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
10399
10400  private static NISuppressor result_shift0_arg1 =
10401      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
10402  private static NISuppressor result_shift0_arg2 =
10403      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
10404  private static NISuppressor arg1_shift0_arg2 =
10405      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
10406
10407  private static NISuppressor arg2_divides_arg1 =
10408      new NISuppressor(1, 2, NumericInt.Divides.class);
10409  private static NISuppressor arg1_divides_arg2 =
10410      new NISuppressor(2, 1, NumericInt.Divides.class);
10411
10412  private static NISuppressor arg2_valid_shift =
10413      new NISuppressor(2, RangeInt.Bound0_63.class);
10414
10415    private static NISuppressionSet suppressions =
10416        new NISuppressionSet(
10417          new NISuppression[] {
10418
10419            // Note that
10420            // x == y && y == z does NOT imply x == z because of possibly
10421            // missing values.  For example:
10422            //
10423            //  Sample    X         Y           Z
10424            //    1       1         1           missing
10425            //    2       0         missing     1
10426            //    3       missing   0           0
10427            //
10428            //  The best solution seems to be to include all three
10429            //  equalities for the suppression
10430
10431            // (r == y) && (y == z) && (r == z) && (r is boolean)
10432            //    ==> r = y | z
10433            new NISuppression(result_eq_arg1, arg1_eq_arg2, result_eq_arg2,
10434                               result_boolean, suppressee),
10435
10436            // (r == y) && (z == 0) && (r is boolean) ==> r = y | z
10437            new NISuppression(result_eq_arg1, result_boolean, arg2_eq_0,
10438                               suppressee),
10439
10440            // (r == z) && (y == 0) && (r is boolean) ==> r = y | z
10441            new NISuppression(result_eq_arg2, result_boolean, arg1_eq_0,
10442                               suppressee),
10443
10444            // (r == 1) && (y == 1) && (z boolean)
10445            new NISuppression(result_eq_1, arg1_eq_1, arg2_boolean, suppressee),
10446
10447            // (r == 1) && (z == 1) && (y boolean)
10448            new NISuppression(result_eq_1, arg2_eq_1, arg1_boolean, suppressee),
10449
10450          });
10451
10452  // Create a suppression factory for functionBinary
10453
10454}
10455
10456/**
10457 * Represents the invariant {@code y = LogicalOr(x, z)} over three long
10458 * scalars. For logical operations, Daikon treats 0 as false and all other values as true.
10459 */
10460public static class LogicalOrLong_yxz extends FunctionBinary {
10461  // We are Serializable, so we specify a version to allow changes to
10462  // method signatures without breaking serialization.  If you add or
10463  // remove fields, you should change this number to the current date.
10464  static final long serialVersionUID = 20031030L;
10465
10466  private static @Prototype LogicalOrLong_yxz proto = new @Prototype LogicalOrLong_yxz ();
10467
10468  /** Returns the prototype invariant for LogicalOrLong_yxz */
10469  public static @Prototype LogicalOrLong_yxz get_proto() {
10470    return proto;
10471  }
10472
10473  /** instantiate an invariant on the specified slice */
10474  @Override
10475  protected LogicalOrLong_yxz instantiate_dyn(@Prototype LogicalOrLong_yxz this, PptSlice slice) {
10476    return new LogicalOrLong_yxz (slice);
10477  }
10478
10479  private LogicalOrLong_yxz (PptSlice slice) {
10480    super(slice);
10481  }
10482
10483  public @Prototype LogicalOrLong_yxz () {
10484    super();
10485  }
10486
10487  private static String[] method_name = new String[] {"", " || ", ""};
10488
10489  @Override
10490  public String[] get_method_name(@GuardSatisfied LogicalOrLong_yxz this) {
10491    return method_name;
10492  }
10493
10494  private static int function_id = -1;
10495
10496  @Override
10497  public int get_function_id() {
10498    return function_id;
10499  }
10500
10501  @Override
10502  public void set_function_id(int function_id) {
10503    assert LogicalOrLong_yxz.function_id == -1;
10504    LogicalOrLong_yxz.function_id = function_id;
10505  }
10506
10507  private static int var_order = 2;
10508
10509  @Override
10510  public int get_var_order(@GuardSatisfied LogicalOrLong_yxz this) {
10511    return var_order;
10512  }
10513
10514  @Pure
10515  @Override
10516  public boolean is_symmetric() {
10517
10518      return true;
10519  }
10520
10521  @Override
10522
10523  public long func(long x, long z) {
10524
10525      if ((x < 0) || (x > 1)) {
10526        throw new ArithmeticException("arg1 (" + x + ") is not boolean ");
10527      }
10528      if ((z < 0) || (z > 1)) {
10529        throw new ArithmeticException("arg2 (" + z + ") is not boolean ");
10530      }
10531
10532    return (((x != 0) || ( z != 0)) ? 1 : 0);
10533  }
10534
10535  @Override
10536  public InvariantStatus check_modified(long x, long y,
10537                                      long z, int count) {
10538    return check_ordered(y, x, z, count);
10539  }
10540
10541  @Override
10542  public InvariantStatus add_modified(long x, long y,
10543                                      long z, int count) {
10544    if (Debug.logDetail()) {
10545      log("result=%s, arg1=%s, arg2=%s", y, x, z);
10546    }
10547    return add_ordered(y, x, z, count);
10548  }
10549
10550  @Pure
10551  @Override
10552  public boolean isLogicalOr() {
10553    return true;
10554  }
10555
10556  /** Returns a list of non-instantiating suppressions for this invariant. */
10557  @Pure
10558  @Override
10559  public @Nullable NISuppressionSet get_ni_suppressions() {
10560    if (NIS.dkconfig_enabled && dkconfig_enabled) {
10561      return suppressions;
10562    } else {
10563      return null;
10564    }
10565  }
10566
10567  /** definition of this invariant (the suppressee) */
10568  private static NISuppressee suppressee = new NISuppressee(LogicalOrLong_yxz.class, 3);
10569
10570  // suppressor definitions (used below)
10571  private static NISuppressor result_eq_arg1 =
10572      new NISuppressor(1, 0, IntEqual.class);
10573  private static NISuppressor result_eq_arg2 =
10574      new NISuppressor(1, 2, IntEqual.class);
10575  private static NISuppressor arg1_eq_arg2 =
10576      new NISuppressor(0, 2, IntEqual.class);
10577
10578  private static NISuppressor result_lt_arg1 =
10579      new NISuppressor(1, 0, IntLessThan.class);
10580  private static NISuppressor result_lt_arg2 =
10581      new NISuppressor(1, 2, IntLessThan.class);
10582  private static NISuppressor arg1_lt_arg2 =
10583      new NISuppressor(0, 2, IntLessThan.class);
10584  private static NISuppressor arg2_lt_arg1 =
10585      new NISuppressor(2, 0, IntLessThan.class);
10586
10587  private static NISuppressor result_le_arg1 =
10588      new NISuppressor(1, 0, IntLessEqual.class);
10589  private static NISuppressor result_le_arg2 =
10590      new NISuppressor(1, 2, IntLessEqual.class);
10591  private static NISuppressor arg1_le_arg2 =
10592      new NISuppressor(0, 2, IntLessEqual.class);
10593  private static NISuppressor arg2_le_arg1 =
10594      new NISuppressor(2, 0, IntLessEqual.class);
10595
10596  private static NISuppressor result_track0_arg1 =
10597      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
10598  private static NISuppressor result_track0_arg2 =
10599      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
10600  private static NISuppressor arg1_track0_arg2 =
10601      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
10602  private static NISuppressor arg1_track0_result =
10603      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
10604  private static NISuppressor arg2_track0_result =
10605      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
10606  private static NISuppressor arg2_track0_arg1 =
10607      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
10608
10609  private static NISuppressor result_eq_1 =
10610      new NISuppressor(1, RangeInt.EqualOne.class);
10611  private static NISuppressor arg1_eq_1 =
10612      new NISuppressor(0, RangeInt.EqualOne.class);
10613  private static NISuppressor arg2_eq_1 =
10614      new NISuppressor(2, RangeInt.EqualOne.class);
10615
10616  private static NISuppressor result_eq_0 =
10617      new NISuppressor(1, RangeInt.EqualZero.class);
10618  private static NISuppressor arg1_eq_0 =
10619      new NISuppressor(0, RangeInt.EqualZero.class);
10620  private static NISuppressor arg2_eq_0 =
10621      new NISuppressor(2, RangeInt.EqualZero.class);
10622
10623  private static NISuppressor result_ne_0 =
10624      new NISuppressor(1, NonZero.class);
10625  private static NISuppressor arg1_ne_0 =
10626      new NISuppressor(0, NonZero.class);
10627  private static NISuppressor arg2_ne_0 =
10628      new NISuppressor(2, NonZero.class);
10629
10630  private static NISuppressor result_ge_0 =
10631      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
10632  private static NISuppressor arg1_ge_0 =
10633      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
10634  private static NISuppressor arg2_ge_0 =
10635      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
10636
10637  private static NISuppressor result_ge_64 =
10638      new NISuppressor(1, RangeInt.GreaterEqual64.class);
10639  private static NISuppressor arg1_ge_64 =
10640      new NISuppressor(0, RangeInt.GreaterEqual64.class);
10641  private static NISuppressor arg2_ge_64 =
10642      new NISuppressor(2, RangeInt.GreaterEqual64.class);
10643
10644  private static NISuppressor result_boolean =
10645      new NISuppressor(1, RangeInt.BooleanVal.class);
10646  private static NISuppressor arg1_boolean =
10647      new NISuppressor(0, RangeInt.BooleanVal.class);
10648  private static NISuppressor arg2_boolean =
10649      new NISuppressor(2, RangeInt.BooleanVal.class);
10650
10651  private static NISuppressor result_even =
10652      new NISuppressor(1, RangeInt.Even.class);
10653  private static NISuppressor arg1_even =
10654      new NISuppressor(0, RangeInt.Even.class);
10655  private static NISuppressor arg2_even =
10656      new NISuppressor(2, RangeInt.Even.class);
10657
10658  private static NISuppressor result_power2 =
10659      new NISuppressor(1, RangeInt.PowerOfTwo.class);
10660  private static NISuppressor arg1_power2 =
10661      new NISuppressor(0, RangeInt.PowerOfTwo.class);
10662  private static NISuppressor arg2_power2 =
10663      new NISuppressor(2, RangeInt.PowerOfTwo.class);
10664
10665  private static NISuppressor result_and0_arg1 =
10666      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
10667  private static NISuppressor result_and0_arg2 =
10668      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
10669  private static NISuppressor arg1_and0_arg2 =
10670      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
10671
10672  // The arguments to bitwise subset are backwards from what one
10673  // might expect.  The second argument is a subset of the first
10674  // argument
10675  private static NISuppressor arg1_bw_subset_arg2 =
10676      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
10677  private static NISuppressor arg2_bw_subset_arg1 =
10678      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
10679
10680  private static NISuppressor result_shift0_arg1 =
10681      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
10682  private static NISuppressor result_shift0_arg2 =
10683      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
10684  private static NISuppressor arg1_shift0_arg2 =
10685      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
10686
10687  private static NISuppressor arg2_divides_arg1 =
10688      new NISuppressor(0, 2, NumericInt.Divides.class);
10689  private static NISuppressor arg1_divides_arg2 =
10690      new NISuppressor(2, 0, NumericInt.Divides.class);
10691
10692  private static NISuppressor arg2_valid_shift =
10693      new NISuppressor(2, RangeInt.Bound0_63.class);
10694
10695    private static NISuppressionSet suppressions =
10696        new NISuppressionSet(
10697          new NISuppression[] {
10698
10699            // Note that
10700            // x == y && y == z does NOT imply x == z because of possibly
10701            // missing values.  For example:
10702            //
10703            //  Sample    X         Y           Z
10704            //    1       1         1           missing
10705            //    2       0         missing     1
10706            //    3       missing   0           0
10707            //
10708            //  The best solution seems to be to include all three
10709            //  equalities for the suppression
10710
10711            // (r == x) && (x == z) && (r == z) && (r is boolean)
10712            //    ==> r = x | z
10713            new NISuppression(result_eq_arg1, arg1_eq_arg2, result_eq_arg2,
10714                               result_boolean, suppressee),
10715
10716            // (r == x) && (z == 0) && (r is boolean) ==> r = x | z
10717            new NISuppression(result_eq_arg1, result_boolean, arg2_eq_0,
10718                               suppressee),
10719
10720            // (r == z) && (x == 0) && (r is boolean) ==> r = x | z
10721            new NISuppression(result_eq_arg2, result_boolean, arg1_eq_0,
10722                               suppressee),
10723
10724            // (r == 1) && (x == 1) && (z boolean)
10725            new NISuppression(result_eq_1, arg1_eq_1, arg2_boolean, suppressee),
10726
10727            // (r == 1) && (z == 1) && (x boolean)
10728            new NISuppression(result_eq_1, arg2_eq_1, arg1_boolean, suppressee),
10729
10730          });
10731
10732  // Create a suppression factory for functionBinary
10733
10734}
10735
10736/**
10737 * Represents the invariant {@code z = LogicalOr(x, y)} over three long
10738 * scalars. For logical operations, Daikon treats 0 as false and all other values as true.
10739 */
10740public static class LogicalOrLong_zxy extends FunctionBinary {
10741  // We are Serializable, so we specify a version to allow changes to
10742  // method signatures without breaking serialization.  If you add or
10743  // remove fields, you should change this number to the current date.
10744  static final long serialVersionUID = 20031030L;
10745
10746  private static @Prototype LogicalOrLong_zxy proto = new @Prototype LogicalOrLong_zxy ();
10747
10748  /** Returns the prototype invariant for LogicalOrLong_zxy */
10749  public static @Prototype LogicalOrLong_zxy get_proto() {
10750    return proto;
10751  }
10752
10753  /** instantiate an invariant on the specified slice */
10754  @Override
10755  protected LogicalOrLong_zxy instantiate_dyn(@Prototype LogicalOrLong_zxy this, PptSlice slice) {
10756    return new LogicalOrLong_zxy (slice);
10757  }
10758
10759  private LogicalOrLong_zxy (PptSlice slice) {
10760    super(slice);
10761  }
10762
10763  public @Prototype LogicalOrLong_zxy () {
10764    super();
10765  }
10766
10767  private static String[] method_name = new String[] {"", " || ", ""};
10768
10769  @Override
10770  public String[] get_method_name(@GuardSatisfied LogicalOrLong_zxy this) {
10771    return method_name;
10772  }
10773
10774  private static int function_id = -1;
10775
10776  @Override
10777  public int get_function_id() {
10778    return function_id;
10779  }
10780
10781  @Override
10782  public void set_function_id(int function_id) {
10783    assert LogicalOrLong_zxy.function_id == -1;
10784    LogicalOrLong_zxy.function_id = function_id;
10785  }
10786
10787  private static int var_order = 3;
10788
10789  @Override
10790  public int get_var_order(@GuardSatisfied LogicalOrLong_zxy this) {
10791    return var_order;
10792  }
10793
10794  @Pure
10795  @Override
10796  public boolean is_symmetric() {
10797
10798      return true;
10799  }
10800
10801  @Override
10802
10803  public long func(long x, long y) {
10804
10805      if ((x < 0) || (x > 1)) {
10806        throw new ArithmeticException("arg1 (" + x + ") is not boolean ");
10807      }
10808      if ((y < 0) || (y > 1)) {
10809        throw new ArithmeticException("arg2 (" + y + ") is not boolean ");
10810      }
10811
10812    return (((x != 0) || ( y != 0)) ? 1 : 0);
10813  }
10814
10815  @Override
10816  public InvariantStatus check_modified(long x, long y,
10817                                      long z, int count) {
10818    return check_ordered(z, x, y, count);
10819  }
10820
10821  @Override
10822  public InvariantStatus add_modified(long x, long y,
10823                                      long z, int count) {
10824    if (Debug.logDetail()) {
10825      log("result=%s, arg1=%s, arg2=%s", z, x, y);
10826    }
10827    return add_ordered(z, x, y, count);
10828  }
10829
10830  @Pure
10831  @Override
10832  public boolean isLogicalOr() {
10833    return true;
10834  }
10835
10836  /** Returns a list of non-instantiating suppressions for this invariant. */
10837  @Pure
10838  @Override
10839  public @Nullable NISuppressionSet get_ni_suppressions() {
10840    if (NIS.dkconfig_enabled && dkconfig_enabled) {
10841      return suppressions;
10842    } else {
10843      return null;
10844    }
10845  }
10846
10847  /** definition of this invariant (the suppressee) */
10848  private static NISuppressee suppressee = new NISuppressee(LogicalOrLong_zxy.class, 3);
10849
10850  // suppressor definitions (used below)
10851  private static NISuppressor result_eq_arg1 =
10852      new NISuppressor(2, 0, IntEqual.class);
10853  private static NISuppressor result_eq_arg2 =
10854      new NISuppressor(2, 1, IntEqual.class);
10855  private static NISuppressor arg1_eq_arg2 =
10856      new NISuppressor(0, 1, IntEqual.class);
10857
10858  private static NISuppressor result_lt_arg1 =
10859      new NISuppressor(2, 0, IntLessThan.class);
10860  private static NISuppressor result_lt_arg2 =
10861      new NISuppressor(2, 1, IntLessThan.class);
10862  private static NISuppressor arg1_lt_arg2 =
10863      new NISuppressor(0, 1, IntLessThan.class);
10864  private static NISuppressor arg2_lt_arg1 =
10865      new NISuppressor(1, 0, IntLessThan.class);
10866
10867  private static NISuppressor result_le_arg1 =
10868      new NISuppressor(2, 0, IntLessEqual.class);
10869  private static NISuppressor result_le_arg2 =
10870      new NISuppressor(2, 1, IntLessEqual.class);
10871  private static NISuppressor arg1_le_arg2 =
10872      new NISuppressor(0, 1, IntLessEqual.class);
10873  private static NISuppressor arg2_le_arg1 =
10874      new NISuppressor(1, 0, IntLessEqual.class);
10875
10876  private static NISuppressor result_track0_arg1 =
10877      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
10878  private static NISuppressor result_track0_arg2 =
10879      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
10880  private static NISuppressor arg1_track0_arg2 =
10881      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
10882  private static NISuppressor arg1_track0_result =
10883      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
10884  private static NISuppressor arg2_track0_result =
10885      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
10886  private static NISuppressor arg2_track0_arg1 =
10887      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
10888
10889  private static NISuppressor result_eq_1 =
10890      new NISuppressor(2, RangeInt.EqualOne.class);
10891  private static NISuppressor arg1_eq_1 =
10892      new NISuppressor(0, RangeInt.EqualOne.class);
10893  private static NISuppressor arg2_eq_1 =
10894      new NISuppressor(1, RangeInt.EqualOne.class);
10895
10896  private static NISuppressor result_eq_0 =
10897      new NISuppressor(2, RangeInt.EqualZero.class);
10898  private static NISuppressor arg1_eq_0 =
10899      new NISuppressor(0, RangeInt.EqualZero.class);
10900  private static NISuppressor arg2_eq_0 =
10901      new NISuppressor(1, RangeInt.EqualZero.class);
10902
10903  private static NISuppressor result_ne_0 =
10904      new NISuppressor(2, NonZero.class);
10905  private static NISuppressor arg1_ne_0 =
10906      new NISuppressor(0, NonZero.class);
10907  private static NISuppressor arg2_ne_0 =
10908      new NISuppressor(1, NonZero.class);
10909
10910  private static NISuppressor result_ge_0 =
10911      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
10912  private static NISuppressor arg1_ge_0 =
10913      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
10914  private static NISuppressor arg2_ge_0 =
10915      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
10916
10917  private static NISuppressor result_ge_64 =
10918      new NISuppressor(2, RangeInt.GreaterEqual64.class);
10919  private static NISuppressor arg1_ge_64 =
10920      new NISuppressor(0, RangeInt.GreaterEqual64.class);
10921  private static NISuppressor arg2_ge_64 =
10922      new NISuppressor(1, RangeInt.GreaterEqual64.class);
10923
10924  private static NISuppressor result_boolean =
10925      new NISuppressor(2, RangeInt.BooleanVal.class);
10926  private static NISuppressor arg1_boolean =
10927      new NISuppressor(0, RangeInt.BooleanVal.class);
10928  private static NISuppressor arg2_boolean =
10929      new NISuppressor(1, RangeInt.BooleanVal.class);
10930
10931  private static NISuppressor result_even =
10932      new NISuppressor(2, RangeInt.Even.class);
10933  private static NISuppressor arg1_even =
10934      new NISuppressor(0, RangeInt.Even.class);
10935  private static NISuppressor arg2_even =
10936      new NISuppressor(1, RangeInt.Even.class);
10937
10938  private static NISuppressor result_power2 =
10939      new NISuppressor(2, RangeInt.PowerOfTwo.class);
10940  private static NISuppressor arg1_power2 =
10941      new NISuppressor(0, RangeInt.PowerOfTwo.class);
10942  private static NISuppressor arg2_power2 =
10943      new NISuppressor(1, RangeInt.PowerOfTwo.class);
10944
10945  private static NISuppressor result_and0_arg1 =
10946      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
10947  private static NISuppressor result_and0_arg2 =
10948      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
10949  private static NISuppressor arg1_and0_arg2 =
10950      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
10951
10952  // The arguments to bitwise subset are backwards from what one
10953  // might expect.  The second argument is a subset of the first
10954  // argument
10955  private static NISuppressor arg1_bw_subset_arg2 =
10956      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
10957  private static NISuppressor arg2_bw_subset_arg1 =
10958      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
10959
10960  private static NISuppressor result_shift0_arg1 =
10961      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
10962  private static NISuppressor result_shift0_arg2 =
10963      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
10964  private static NISuppressor arg1_shift0_arg2 =
10965      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
10966
10967  private static NISuppressor arg2_divides_arg1 =
10968      new NISuppressor(0, 1, NumericInt.Divides.class);
10969  private static NISuppressor arg1_divides_arg2 =
10970      new NISuppressor(1, 0, NumericInt.Divides.class);
10971
10972  private static NISuppressor arg2_valid_shift =
10973      new NISuppressor(1, RangeInt.Bound0_63.class);
10974
10975    private static NISuppressionSet suppressions =
10976        new NISuppressionSet(
10977          new NISuppression[] {
10978
10979            // Note that
10980            // x == y && y == z does NOT imply x == z because of possibly
10981            // missing values.  For example:
10982            //
10983            //  Sample    X         Y           Z
10984            //    1       1         1           missing
10985            //    2       0         missing     1
10986            //    3       missing   0           0
10987            //
10988            //  The best solution seems to be to include all three
10989            //  equalities for the suppression
10990
10991            // (r == x) && (x == y) && (r == y) && (r is boolean)
10992            //    ==> r = x | y
10993            new NISuppression(result_eq_arg1, arg1_eq_arg2, result_eq_arg2,
10994                               result_boolean, suppressee),
10995
10996            // (r == x) && (y == 0) && (r is boolean) ==> r = x | y
10997            new NISuppression(result_eq_arg1, result_boolean, arg2_eq_0,
10998                               suppressee),
10999
11000            // (r == y) && (x == 0) && (r is boolean) ==> r = x | y
11001            new NISuppression(result_eq_arg2, result_boolean, arg1_eq_0,
11002                               suppressee),
11003
11004            // (r == 1) && (x == 1) && (y boolean)
11005            new NISuppression(result_eq_1, arg1_eq_1, arg2_boolean, suppressee),
11006
11007            // (r == 1) && (y == 1) && (x boolean)
11008            new NISuppression(result_eq_1, arg2_eq_1, arg1_boolean, suppressee),
11009
11010          });
11011
11012  // Create a suppression factory for functionBinary
11013
11014}
11015
11016  // #define EQUALITY_SUPPRESS 1
11017
11018  // default is that it is not this function, overriden in the subclass
11019  @Pure
11020  public boolean isGcd() {
11021    return false;
11022  }
11023
11024/**
11025 * Represents the invariant {@code x = Gcd(y, z)} over three long
11026 * scalars. 
11027 */
11028public static class GcdLong_xyz extends FunctionBinary {
11029  // We are Serializable, so we specify a version to allow changes to
11030  // method signatures without breaking serialization.  If you add or
11031  // remove fields, you should change this number to the current date.
11032  static final long serialVersionUID = 20031030L;
11033
11034  private static @Prototype GcdLong_xyz proto = new @Prototype GcdLong_xyz ();
11035
11036  /** Returns the prototype invariant for GcdLong_xyz */
11037  public static @Prototype GcdLong_xyz get_proto() {
11038    return proto;
11039  }
11040
11041  /** instantiate an invariant on the specified slice */
11042  @Override
11043  protected GcdLong_xyz instantiate_dyn(@Prototype GcdLong_xyz this, PptSlice slice) {
11044    return new GcdLong_xyz (slice);
11045  }
11046
11047  private GcdLong_xyz (PptSlice slice) {
11048    super(slice);
11049  }
11050
11051  public @Prototype GcdLong_xyz () {
11052    super();
11053  }
11054
11055  private static String[] method_name = new String[] {"org.plumelib.util.MathPlume.gcd(", ", ", ")"};
11056
11057  @Override
11058  public String[] get_method_name(@GuardSatisfied GcdLong_xyz this) {
11059    return method_name;
11060  }
11061
11062  private static int function_id = -1;
11063
11064  @Override
11065  public int get_function_id() {
11066    return function_id;
11067  }
11068
11069  @Override
11070  public void set_function_id(int function_id) {
11071    assert GcdLong_xyz.function_id == -1;
11072    GcdLong_xyz.function_id = function_id;
11073  }
11074
11075  private static int var_order = 1;
11076
11077  @Override
11078  public int get_var_order(@GuardSatisfied GcdLong_xyz this) {
11079    return var_order;
11080  }
11081
11082  @Pure
11083  @Override
11084  public boolean is_symmetric() {
11085
11086      return true;
11087  }
11088
11089  @Override
11090
11091  public long func(long y, long z) {
11092
11093    return MathPlume.gcd(y, z);
11094  }
11095
11096  @Override
11097  public InvariantStatus check_modified(long x, long y,
11098                                      long z, int count) {
11099    return check_ordered(x, y, z, count);
11100  }
11101
11102  @Override
11103  public InvariantStatus add_modified(long x, long y,
11104                                      long z, int count) {
11105    if (Debug.logDetail()) {
11106      log("result=%s, arg1=%s, arg2=%s", x, y, z);
11107    }
11108    return add_ordered(x, y, z, count);
11109  }
11110
11111  @Pure
11112  @Override
11113  public boolean isGcd() {
11114    return true;
11115  }
11116
11117  /** Returns a list of non-instantiating suppressions for this invariant. */
11118  @Pure
11119  @Override
11120  public @Nullable NISuppressionSet get_ni_suppressions() {
11121    if (NIS.dkconfig_enabled && dkconfig_enabled) {
11122      return suppressions;
11123    } else {
11124      return null;
11125    }
11126  }
11127
11128  /** definition of this invariant (the suppressee) */
11129  private static NISuppressee suppressee = new NISuppressee(GcdLong_xyz.class, 3);
11130
11131  // suppressor definitions (used below)
11132  private static NISuppressor result_eq_arg1 =
11133      new NISuppressor(0, 1, IntEqual.class);
11134  private static NISuppressor result_eq_arg2 =
11135      new NISuppressor(0, 2, IntEqual.class);
11136  private static NISuppressor arg1_eq_arg2 =
11137      new NISuppressor(1, 2, IntEqual.class);
11138
11139  private static NISuppressor result_lt_arg1 =
11140      new NISuppressor(0, 1, IntLessThan.class);
11141  private static NISuppressor result_lt_arg2 =
11142      new NISuppressor(0, 2, IntLessThan.class);
11143  private static NISuppressor arg1_lt_arg2 =
11144      new NISuppressor(1, 2, IntLessThan.class);
11145  private static NISuppressor arg2_lt_arg1 =
11146      new NISuppressor(2, 1, IntLessThan.class);
11147
11148  private static NISuppressor result_le_arg1 =
11149      new NISuppressor(0, 1, IntLessEqual.class);
11150  private static NISuppressor result_le_arg2 =
11151      new NISuppressor(0, 2, IntLessEqual.class);
11152  private static NISuppressor arg1_le_arg2 =
11153      new NISuppressor(1, 2, IntLessEqual.class);
11154  private static NISuppressor arg2_le_arg1 =
11155      new NISuppressor(2, 1, IntLessEqual.class);
11156
11157  private static NISuppressor result_track0_arg1 =
11158      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
11159  private static NISuppressor result_track0_arg2 =
11160      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
11161  private static NISuppressor arg1_track0_arg2 =
11162      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
11163  private static NISuppressor arg1_track0_result =
11164      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
11165  private static NISuppressor arg2_track0_result =
11166      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
11167  private static NISuppressor arg2_track0_arg1 =
11168      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
11169
11170  private static NISuppressor result_eq_1 =
11171      new NISuppressor(0, RangeInt.EqualOne.class);
11172  private static NISuppressor arg1_eq_1 =
11173      new NISuppressor(1, RangeInt.EqualOne.class);
11174  private static NISuppressor arg2_eq_1 =
11175      new NISuppressor(2, RangeInt.EqualOne.class);
11176
11177  private static NISuppressor result_eq_0 =
11178      new NISuppressor(0, RangeInt.EqualZero.class);
11179  private static NISuppressor arg1_eq_0 =
11180      new NISuppressor(1, RangeInt.EqualZero.class);
11181  private static NISuppressor arg2_eq_0 =
11182      new NISuppressor(2, RangeInt.EqualZero.class);
11183
11184  private static NISuppressor result_ne_0 =
11185      new NISuppressor(0, NonZero.class);
11186  private static NISuppressor arg1_ne_0 =
11187      new NISuppressor(1, NonZero.class);
11188  private static NISuppressor arg2_ne_0 =
11189      new NISuppressor(2, NonZero.class);
11190
11191  private static NISuppressor result_ge_0 =
11192      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
11193  private static NISuppressor arg1_ge_0 =
11194      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
11195  private static NISuppressor arg2_ge_0 =
11196      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
11197
11198  private static NISuppressor result_ge_64 =
11199      new NISuppressor(0, RangeInt.GreaterEqual64.class);
11200  private static NISuppressor arg1_ge_64 =
11201      new NISuppressor(1, RangeInt.GreaterEqual64.class);
11202  private static NISuppressor arg2_ge_64 =
11203      new NISuppressor(2, RangeInt.GreaterEqual64.class);
11204
11205  private static NISuppressor result_boolean =
11206      new NISuppressor(0, RangeInt.BooleanVal.class);
11207  private static NISuppressor arg1_boolean =
11208      new NISuppressor(1, RangeInt.BooleanVal.class);
11209  private static NISuppressor arg2_boolean =
11210      new NISuppressor(2, RangeInt.BooleanVal.class);
11211
11212  private static NISuppressor result_even =
11213      new NISuppressor(0, RangeInt.Even.class);
11214  private static NISuppressor arg1_even =
11215      new NISuppressor(1, RangeInt.Even.class);
11216  private static NISuppressor arg2_even =
11217      new NISuppressor(2, RangeInt.Even.class);
11218
11219  private static NISuppressor result_power2 =
11220      new NISuppressor(0, RangeInt.PowerOfTwo.class);
11221  private static NISuppressor arg1_power2 =
11222      new NISuppressor(1, RangeInt.PowerOfTwo.class);
11223  private static NISuppressor arg2_power2 =
11224      new NISuppressor(2, RangeInt.PowerOfTwo.class);
11225
11226  private static NISuppressor result_and0_arg1 =
11227      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
11228  private static NISuppressor result_and0_arg2 =
11229      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
11230  private static NISuppressor arg1_and0_arg2 =
11231      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
11232
11233  // The arguments to bitwise subset are backwards from what one
11234  // might expect.  The second argument is a subset of the first
11235  // argument
11236  private static NISuppressor arg1_bw_subset_arg2 =
11237      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
11238  private static NISuppressor arg2_bw_subset_arg1 =
11239      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
11240
11241  private static NISuppressor result_shift0_arg1 =
11242      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
11243  private static NISuppressor result_shift0_arg2 =
11244      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
11245  private static NISuppressor arg1_shift0_arg2 =
11246      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
11247
11248  private static NISuppressor arg2_divides_arg1 =
11249      new NISuppressor(1, 2, NumericInt.Divides.class);
11250  private static NISuppressor arg1_divides_arg2 =
11251      new NISuppressor(2, 1, NumericInt.Divides.class);
11252
11253  private static NISuppressor arg2_valid_shift =
11254      new NISuppressor(2, RangeInt.Bound0_63.class);
11255
11256    // gcd (0, y) == y
11257    // gcd (0, 0) == 0
11258    // gcd (1, y) == 1
11259
11260    private static NISuppressionSet suppressions =
11261        new NISuppressionSet(
11262          new NISuppression[] {
11263
11264            // (r == y) && (y == z) && (r == z) && (r >= 0)
11265            //    ==> r = Gcd (y, z)
11266            new NISuppression(result_eq_arg1, arg1_eq_arg2, result_eq_arg2,
11267                               result_ge_0, suppressee),
11268
11269            // (r == y) && (z == 0) && (r >= 0) ==> r = gcd (y, z)
11270            new NISuppression(result_eq_arg1, result_ge_0, arg2_eq_0, suppressee),
11271
11272            // (r == z) && (y == 0) && (r >= 0) ==> r = gcd (y, z)
11273            new NISuppression(result_eq_arg2, result_ge_0, arg1_eq_0, suppressee),
11274
11275            // (r == 1) && (z == 1)        ==> r = gcd (y, art2)
11276            new NISuppression(result_eq_1, arg2_eq_1, suppressee),
11277
11278            // (r == 1) && (y == 1)        ==> r = gcd (y, art2)
11279            new NISuppression(result_eq_1, arg1_eq_1, suppressee),
11280
11281            // (r == y) && (y divides z) && (r >= 0)
11282            new NISuppression(result_eq_arg1, arg1_divides_arg2, result_ge_0, suppressee),
11283
11284            // (r == z) && (z divides y) && (r >= 0)
11285            new NISuppression(result_eq_arg2, arg2_divides_arg1, result_ge_0, suppressee),
11286
11287            // (r == z) && (z boolean) && (z==0 ==> y==0)
11288            // 0 = gcd (y, 0) true when (y == 0)
11289            // 1 = gcd (y, 1) always true
11290            new NISuppression(result_eq_arg2, arg2_track0_arg1, arg2_boolean,
11291                               suppressee),
11292
11293            // (r == y) && (y boolean) && (y==0 ==> z==0)
11294            // 0 = gcd (0, z), true if (z == 0)
11295            // 1 = gcd (1, z), always true
11296            new NISuppression(result_eq_arg1, arg1_boolean, arg1_track0_arg2,
11297                               suppressee),
11298
11299          });
11300
11301  // Create a suppression factory for functionBinary
11302
11303}
11304
11305/**
11306 * Represents the invariant {@code y = Gcd(x, z)} over three long
11307 * scalars. 
11308 */
11309public static class GcdLong_yxz extends FunctionBinary {
11310  // We are Serializable, so we specify a version to allow changes to
11311  // method signatures without breaking serialization.  If you add or
11312  // remove fields, you should change this number to the current date.
11313  static final long serialVersionUID = 20031030L;
11314
11315  private static @Prototype GcdLong_yxz proto = new @Prototype GcdLong_yxz ();
11316
11317  /** Returns the prototype invariant for GcdLong_yxz */
11318  public static @Prototype GcdLong_yxz get_proto() {
11319    return proto;
11320  }
11321
11322  /** instantiate an invariant on the specified slice */
11323  @Override
11324  protected GcdLong_yxz instantiate_dyn(@Prototype GcdLong_yxz this, PptSlice slice) {
11325    return new GcdLong_yxz (slice);
11326  }
11327
11328  private GcdLong_yxz (PptSlice slice) {
11329    super(slice);
11330  }
11331
11332  public @Prototype GcdLong_yxz () {
11333    super();
11334  }
11335
11336  private static String[] method_name = new String[] {"org.plumelib.util.MathPlume.gcd(", ", ", ")"};
11337
11338  @Override
11339  public String[] get_method_name(@GuardSatisfied GcdLong_yxz this) {
11340    return method_name;
11341  }
11342
11343  private static int function_id = -1;
11344
11345  @Override
11346  public int get_function_id() {
11347    return function_id;
11348  }
11349
11350  @Override
11351  public void set_function_id(int function_id) {
11352    assert GcdLong_yxz.function_id == -1;
11353    GcdLong_yxz.function_id = function_id;
11354  }
11355
11356  private static int var_order = 2;
11357
11358  @Override
11359  public int get_var_order(@GuardSatisfied GcdLong_yxz this) {
11360    return var_order;
11361  }
11362
11363  @Pure
11364  @Override
11365  public boolean is_symmetric() {
11366
11367      return true;
11368  }
11369
11370  @Override
11371
11372  public long func(long x, long z) {
11373
11374    return MathPlume.gcd(x, z);
11375  }
11376
11377  @Override
11378  public InvariantStatus check_modified(long x, long y,
11379                                      long z, int count) {
11380    return check_ordered(y, x, z, count);
11381  }
11382
11383  @Override
11384  public InvariantStatus add_modified(long x, long y,
11385                                      long z, int count) {
11386    if (Debug.logDetail()) {
11387      log("result=%s, arg1=%s, arg2=%s", y, x, z);
11388    }
11389    return add_ordered(y, x, z, count);
11390  }
11391
11392  @Pure
11393  @Override
11394  public boolean isGcd() {
11395    return true;
11396  }
11397
11398  /** Returns a list of non-instantiating suppressions for this invariant. */
11399  @Pure
11400  @Override
11401  public @Nullable NISuppressionSet get_ni_suppressions() {
11402    if (NIS.dkconfig_enabled && dkconfig_enabled) {
11403      return suppressions;
11404    } else {
11405      return null;
11406    }
11407  }
11408
11409  /** definition of this invariant (the suppressee) */
11410  private static NISuppressee suppressee = new NISuppressee(GcdLong_yxz.class, 3);
11411
11412  // suppressor definitions (used below)
11413  private static NISuppressor result_eq_arg1 =
11414      new NISuppressor(1, 0, IntEqual.class);
11415  private static NISuppressor result_eq_arg2 =
11416      new NISuppressor(1, 2, IntEqual.class);
11417  private static NISuppressor arg1_eq_arg2 =
11418      new NISuppressor(0, 2, IntEqual.class);
11419
11420  private static NISuppressor result_lt_arg1 =
11421      new NISuppressor(1, 0, IntLessThan.class);
11422  private static NISuppressor result_lt_arg2 =
11423      new NISuppressor(1, 2, IntLessThan.class);
11424  private static NISuppressor arg1_lt_arg2 =
11425      new NISuppressor(0, 2, IntLessThan.class);
11426  private static NISuppressor arg2_lt_arg1 =
11427      new NISuppressor(2, 0, IntLessThan.class);
11428
11429  private static NISuppressor result_le_arg1 =
11430      new NISuppressor(1, 0, IntLessEqual.class);
11431  private static NISuppressor result_le_arg2 =
11432      new NISuppressor(1, 2, IntLessEqual.class);
11433  private static NISuppressor arg1_le_arg2 =
11434      new NISuppressor(0, 2, IntLessEqual.class);
11435  private static NISuppressor arg2_le_arg1 =
11436      new NISuppressor(2, 0, IntLessEqual.class);
11437
11438  private static NISuppressor result_track0_arg1 =
11439      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
11440  private static NISuppressor result_track0_arg2 =
11441      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
11442  private static NISuppressor arg1_track0_arg2 =
11443      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
11444  private static NISuppressor arg1_track0_result =
11445      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
11446  private static NISuppressor arg2_track0_result =
11447      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
11448  private static NISuppressor arg2_track0_arg1 =
11449      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
11450
11451  private static NISuppressor result_eq_1 =
11452      new NISuppressor(1, RangeInt.EqualOne.class);
11453  private static NISuppressor arg1_eq_1 =
11454      new NISuppressor(0, RangeInt.EqualOne.class);
11455  private static NISuppressor arg2_eq_1 =
11456      new NISuppressor(2, RangeInt.EqualOne.class);
11457
11458  private static NISuppressor result_eq_0 =
11459      new NISuppressor(1, RangeInt.EqualZero.class);
11460  private static NISuppressor arg1_eq_0 =
11461      new NISuppressor(0, RangeInt.EqualZero.class);
11462  private static NISuppressor arg2_eq_0 =
11463      new NISuppressor(2, RangeInt.EqualZero.class);
11464
11465  private static NISuppressor result_ne_0 =
11466      new NISuppressor(1, NonZero.class);
11467  private static NISuppressor arg1_ne_0 =
11468      new NISuppressor(0, NonZero.class);
11469  private static NISuppressor arg2_ne_0 =
11470      new NISuppressor(2, NonZero.class);
11471
11472  private static NISuppressor result_ge_0 =
11473      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
11474  private static NISuppressor arg1_ge_0 =
11475      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
11476  private static NISuppressor arg2_ge_0 =
11477      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
11478
11479  private static NISuppressor result_ge_64 =
11480      new NISuppressor(1, RangeInt.GreaterEqual64.class);
11481  private static NISuppressor arg1_ge_64 =
11482      new NISuppressor(0, RangeInt.GreaterEqual64.class);
11483  private static NISuppressor arg2_ge_64 =
11484      new NISuppressor(2, RangeInt.GreaterEqual64.class);
11485
11486  private static NISuppressor result_boolean =
11487      new NISuppressor(1, RangeInt.BooleanVal.class);
11488  private static NISuppressor arg1_boolean =
11489      new NISuppressor(0, RangeInt.BooleanVal.class);
11490  private static NISuppressor arg2_boolean =
11491      new NISuppressor(2, RangeInt.BooleanVal.class);
11492
11493  private static NISuppressor result_even =
11494      new NISuppressor(1, RangeInt.Even.class);
11495  private static NISuppressor arg1_even =
11496      new NISuppressor(0, RangeInt.Even.class);
11497  private static NISuppressor arg2_even =
11498      new NISuppressor(2, RangeInt.Even.class);
11499
11500  private static NISuppressor result_power2 =
11501      new NISuppressor(1, RangeInt.PowerOfTwo.class);
11502  private static NISuppressor arg1_power2 =
11503      new NISuppressor(0, RangeInt.PowerOfTwo.class);
11504  private static NISuppressor arg2_power2 =
11505      new NISuppressor(2, RangeInt.PowerOfTwo.class);
11506
11507  private static NISuppressor result_and0_arg1 =
11508      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
11509  private static NISuppressor result_and0_arg2 =
11510      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
11511  private static NISuppressor arg1_and0_arg2 =
11512      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
11513
11514  // The arguments to bitwise subset are backwards from what one
11515  // might expect.  The second argument is a subset of the first
11516  // argument
11517  private static NISuppressor arg1_bw_subset_arg2 =
11518      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
11519  private static NISuppressor arg2_bw_subset_arg1 =
11520      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
11521
11522  private static NISuppressor result_shift0_arg1 =
11523      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
11524  private static NISuppressor result_shift0_arg2 =
11525      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
11526  private static NISuppressor arg1_shift0_arg2 =
11527      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
11528
11529  private static NISuppressor arg2_divides_arg1 =
11530      new NISuppressor(0, 2, NumericInt.Divides.class);
11531  private static NISuppressor arg1_divides_arg2 =
11532      new NISuppressor(2, 0, NumericInt.Divides.class);
11533
11534  private static NISuppressor arg2_valid_shift =
11535      new NISuppressor(2, RangeInt.Bound0_63.class);
11536
11537    // gcd (0, y) == y
11538    // gcd (0, 0) == 0
11539    // gcd (1, y) == 1
11540
11541    private static NISuppressionSet suppressions =
11542        new NISuppressionSet(
11543          new NISuppression[] {
11544
11545            // (r == x) && (x == z) && (r == z) && (r >= 0)
11546            //    ==> r = Gcd (x, z)
11547            new NISuppression(result_eq_arg1, arg1_eq_arg2, result_eq_arg2,
11548                               result_ge_0, suppressee),
11549
11550            // (r == x) && (z == 0) && (r >= 0) ==> r = gcd (x, z)
11551            new NISuppression(result_eq_arg1, result_ge_0, arg2_eq_0, suppressee),
11552
11553            // (r == z) && (x == 0) && (r >= 0) ==> r = gcd (x, z)
11554            new NISuppression(result_eq_arg2, result_ge_0, arg1_eq_0, suppressee),
11555
11556            // (r == 1) && (z == 1)        ==> r = gcd (x, art2)
11557            new NISuppression(result_eq_1, arg2_eq_1, suppressee),
11558
11559            // (r == 1) && (x == 1)        ==> r = gcd (x, art2)
11560            new NISuppression(result_eq_1, arg1_eq_1, suppressee),
11561
11562            // (r == x) && (x divides z) && (r >= 0)
11563            new NISuppression(result_eq_arg1, arg1_divides_arg2, result_ge_0, suppressee),
11564
11565            // (r == z) && (z divides x) && (r >= 0)
11566            new NISuppression(result_eq_arg2, arg2_divides_arg1, result_ge_0, suppressee),
11567
11568            // (r == z) && (z boolean) && (z==0 ==> x==0)
11569            // 0 = gcd (x, 0) true when (x == 0)
11570            // 1 = gcd (x, 1) always true
11571            new NISuppression(result_eq_arg2, arg2_track0_arg1, arg2_boolean,
11572                               suppressee),
11573
11574            // (r == x) && (x boolean) && (x==0 ==> z==0)
11575            // 0 = gcd (0, z), true if (z == 0)
11576            // 1 = gcd (1, z), always true
11577            new NISuppression(result_eq_arg1, arg1_boolean, arg1_track0_arg2,
11578                               suppressee),
11579
11580          });
11581
11582  // Create a suppression factory for functionBinary
11583
11584}
11585
11586/**
11587 * Represents the invariant {@code z = Gcd(x, y)} over three long
11588 * scalars. 
11589 */
11590public static class GcdLong_zxy extends FunctionBinary {
11591  // We are Serializable, so we specify a version to allow changes to
11592  // method signatures without breaking serialization.  If you add or
11593  // remove fields, you should change this number to the current date.
11594  static final long serialVersionUID = 20031030L;
11595
11596  private static @Prototype GcdLong_zxy proto = new @Prototype GcdLong_zxy ();
11597
11598  /** Returns the prototype invariant for GcdLong_zxy */
11599  public static @Prototype GcdLong_zxy get_proto() {
11600    return proto;
11601  }
11602
11603  /** instantiate an invariant on the specified slice */
11604  @Override
11605  protected GcdLong_zxy instantiate_dyn(@Prototype GcdLong_zxy this, PptSlice slice) {
11606    return new GcdLong_zxy (slice);
11607  }
11608
11609  private GcdLong_zxy (PptSlice slice) {
11610    super(slice);
11611  }
11612
11613  public @Prototype GcdLong_zxy () {
11614    super();
11615  }
11616
11617  private static String[] method_name = new String[] {"org.plumelib.util.MathPlume.gcd(", ", ", ")"};
11618
11619  @Override
11620  public String[] get_method_name(@GuardSatisfied GcdLong_zxy this) {
11621    return method_name;
11622  }
11623
11624  private static int function_id = -1;
11625
11626  @Override
11627  public int get_function_id() {
11628    return function_id;
11629  }
11630
11631  @Override
11632  public void set_function_id(int function_id) {
11633    assert GcdLong_zxy.function_id == -1;
11634    GcdLong_zxy.function_id = function_id;
11635  }
11636
11637  private static int var_order = 3;
11638
11639  @Override
11640  public int get_var_order(@GuardSatisfied GcdLong_zxy this) {
11641    return var_order;
11642  }
11643
11644  @Pure
11645  @Override
11646  public boolean is_symmetric() {
11647
11648      return true;
11649  }
11650
11651  @Override
11652
11653  public long func(long x, long y) {
11654
11655    return MathPlume.gcd(x, y);
11656  }
11657
11658  @Override
11659  public InvariantStatus check_modified(long x, long y,
11660                                      long z, int count) {
11661    return check_ordered(z, x, y, count);
11662  }
11663
11664  @Override
11665  public InvariantStatus add_modified(long x, long y,
11666                                      long z, int count) {
11667    if (Debug.logDetail()) {
11668      log("result=%s, arg1=%s, arg2=%s", z, x, y);
11669    }
11670    return add_ordered(z, x, y, count);
11671  }
11672
11673  @Pure
11674  @Override
11675  public boolean isGcd() {
11676    return true;
11677  }
11678
11679  /** Returns a list of non-instantiating suppressions for this invariant. */
11680  @Pure
11681  @Override
11682  public @Nullable NISuppressionSet get_ni_suppressions() {
11683    if (NIS.dkconfig_enabled && dkconfig_enabled) {
11684      return suppressions;
11685    } else {
11686      return null;
11687    }
11688  }
11689
11690  /** definition of this invariant (the suppressee) */
11691  private static NISuppressee suppressee = new NISuppressee(GcdLong_zxy.class, 3);
11692
11693  // suppressor definitions (used below)
11694  private static NISuppressor result_eq_arg1 =
11695      new NISuppressor(2, 0, IntEqual.class);
11696  private static NISuppressor result_eq_arg2 =
11697      new NISuppressor(2, 1, IntEqual.class);
11698  private static NISuppressor arg1_eq_arg2 =
11699      new NISuppressor(0, 1, IntEqual.class);
11700
11701  private static NISuppressor result_lt_arg1 =
11702      new NISuppressor(2, 0, IntLessThan.class);
11703  private static NISuppressor result_lt_arg2 =
11704      new NISuppressor(2, 1, IntLessThan.class);
11705  private static NISuppressor arg1_lt_arg2 =
11706      new NISuppressor(0, 1, IntLessThan.class);
11707  private static NISuppressor arg2_lt_arg1 =
11708      new NISuppressor(1, 0, IntLessThan.class);
11709
11710  private static NISuppressor result_le_arg1 =
11711      new NISuppressor(2, 0, IntLessEqual.class);
11712  private static NISuppressor result_le_arg2 =
11713      new NISuppressor(2, 1, IntLessEqual.class);
11714  private static NISuppressor arg1_le_arg2 =
11715      new NISuppressor(0, 1, IntLessEqual.class);
11716  private static NISuppressor arg2_le_arg1 =
11717      new NISuppressor(1, 0, IntLessEqual.class);
11718
11719  private static NISuppressor result_track0_arg1 =
11720      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
11721  private static NISuppressor result_track0_arg2 =
11722      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
11723  private static NISuppressor arg1_track0_arg2 =
11724      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
11725  private static NISuppressor arg1_track0_result =
11726      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
11727  private static NISuppressor arg2_track0_result =
11728      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
11729  private static NISuppressor arg2_track0_arg1 =
11730      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
11731
11732  private static NISuppressor result_eq_1 =
11733      new NISuppressor(2, RangeInt.EqualOne.class);
11734  private static NISuppressor arg1_eq_1 =
11735      new NISuppressor(0, RangeInt.EqualOne.class);
11736  private static NISuppressor arg2_eq_1 =
11737      new NISuppressor(1, RangeInt.EqualOne.class);
11738
11739  private static NISuppressor result_eq_0 =
11740      new NISuppressor(2, RangeInt.EqualZero.class);
11741  private static NISuppressor arg1_eq_0 =
11742      new NISuppressor(0, RangeInt.EqualZero.class);
11743  private static NISuppressor arg2_eq_0 =
11744      new NISuppressor(1, RangeInt.EqualZero.class);
11745
11746  private static NISuppressor result_ne_0 =
11747      new NISuppressor(2, NonZero.class);
11748  private static NISuppressor arg1_ne_0 =
11749      new NISuppressor(0, NonZero.class);
11750  private static NISuppressor arg2_ne_0 =
11751      new NISuppressor(1, NonZero.class);
11752
11753  private static NISuppressor result_ge_0 =
11754      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
11755  private static NISuppressor arg1_ge_0 =
11756      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
11757  private static NISuppressor arg2_ge_0 =
11758      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
11759
11760  private static NISuppressor result_ge_64 =
11761      new NISuppressor(2, RangeInt.GreaterEqual64.class);
11762  private static NISuppressor arg1_ge_64 =
11763      new NISuppressor(0, RangeInt.GreaterEqual64.class);
11764  private static NISuppressor arg2_ge_64 =
11765      new NISuppressor(1, RangeInt.GreaterEqual64.class);
11766
11767  private static NISuppressor result_boolean =
11768      new NISuppressor(2, RangeInt.BooleanVal.class);
11769  private static NISuppressor arg1_boolean =
11770      new NISuppressor(0, RangeInt.BooleanVal.class);
11771  private static NISuppressor arg2_boolean =
11772      new NISuppressor(1, RangeInt.BooleanVal.class);
11773
11774  private static NISuppressor result_even =
11775      new NISuppressor(2, RangeInt.Even.class);
11776  private static NISuppressor arg1_even =
11777      new NISuppressor(0, RangeInt.Even.class);
11778  private static NISuppressor arg2_even =
11779      new NISuppressor(1, RangeInt.Even.class);
11780
11781  private static NISuppressor result_power2 =
11782      new NISuppressor(2, RangeInt.PowerOfTwo.class);
11783  private static NISuppressor arg1_power2 =
11784      new NISuppressor(0, RangeInt.PowerOfTwo.class);
11785  private static NISuppressor arg2_power2 =
11786      new NISuppressor(1, RangeInt.PowerOfTwo.class);
11787
11788  private static NISuppressor result_and0_arg1 =
11789      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
11790  private static NISuppressor result_and0_arg2 =
11791      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
11792  private static NISuppressor arg1_and0_arg2 =
11793      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
11794
11795  // The arguments to bitwise subset are backwards from what one
11796  // might expect.  The second argument is a subset of the first
11797  // argument
11798  private static NISuppressor arg1_bw_subset_arg2 =
11799      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
11800  private static NISuppressor arg2_bw_subset_arg1 =
11801      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
11802
11803  private static NISuppressor result_shift0_arg1 =
11804      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
11805  private static NISuppressor result_shift0_arg2 =
11806      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
11807  private static NISuppressor arg1_shift0_arg2 =
11808      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
11809
11810  private static NISuppressor arg2_divides_arg1 =
11811      new NISuppressor(0, 1, NumericInt.Divides.class);
11812  private static NISuppressor arg1_divides_arg2 =
11813      new NISuppressor(1, 0, NumericInt.Divides.class);
11814
11815  private static NISuppressor arg2_valid_shift =
11816      new NISuppressor(1, RangeInt.Bound0_63.class);
11817
11818    // gcd (0, y) == y
11819    // gcd (0, 0) == 0
11820    // gcd (1, y) == 1
11821
11822    private static NISuppressionSet suppressions =
11823        new NISuppressionSet(
11824          new NISuppression[] {
11825
11826            // (r == x) && (x == y) && (r == y) && (r >= 0)
11827            //    ==> r = Gcd (x, y)
11828            new NISuppression(result_eq_arg1, arg1_eq_arg2, result_eq_arg2,
11829                               result_ge_0, suppressee),
11830
11831            // (r == x) && (y == 0) && (r >= 0) ==> r = gcd (x, y)
11832            new NISuppression(result_eq_arg1, result_ge_0, arg2_eq_0, suppressee),
11833
11834            // (r == y) && (x == 0) && (r >= 0) ==> r = gcd (x, y)
11835            new NISuppression(result_eq_arg2, result_ge_0, arg1_eq_0, suppressee),
11836
11837            // (r == 1) && (y == 1)        ==> r = gcd (x, art2)
11838            new NISuppression(result_eq_1, arg2_eq_1, suppressee),
11839
11840            // (r == 1) && (x == 1)        ==> r = gcd (x, art2)
11841            new NISuppression(result_eq_1, arg1_eq_1, suppressee),
11842
11843            // (r == x) && (x divides y) && (r >= 0)
11844            new NISuppression(result_eq_arg1, arg1_divides_arg2, result_ge_0, suppressee),
11845
11846            // (r == y) && (y divides x) && (r >= 0)
11847            new NISuppression(result_eq_arg2, arg2_divides_arg1, result_ge_0, suppressee),
11848
11849            // (r == y) && (y boolean) && (y==0 ==> x==0)
11850            // 0 = gcd (x, 0) true when (x == 0)
11851            // 1 = gcd (x, 1) always true
11852            new NISuppression(result_eq_arg2, arg2_track0_arg1, arg2_boolean,
11853                               suppressee),
11854
11855            // (r == x) && (x boolean) && (x==0 ==> y==0)
11856            // 0 = gcd (0, y), true if (y == 0)
11857            // 1 = gcd (1, y), always true
11858            new NISuppression(result_eq_arg1, arg1_boolean, arg1_track0_arg2,
11859                               suppressee),
11860
11861          });
11862
11863  // Create a suppression factory for functionBinary
11864
11865}
11866
11867  // default is that it is not this function, overriden in the subclass
11868  @Pure
11869  public boolean isMod() {
11870    return false;
11871  }
11872
11873/**
11874 * Represents the invariant {@code x = Mod(y, z)} over three long
11875 * scalars. 
11876 */
11877public static class ModLong_xyz extends FunctionBinary {
11878  // We are Serializable, so we specify a version to allow changes to
11879  // method signatures without breaking serialization.  If you add or
11880  // remove fields, you should change this number to the current date.
11881  static final long serialVersionUID = 20031030L;
11882
11883  private static @Prototype ModLong_xyz proto = new @Prototype ModLong_xyz ();
11884
11885  /** Returns the prototype invariant for ModLong_xyz */
11886  public static @Prototype ModLong_xyz get_proto() {
11887    return proto;
11888  }
11889
11890  /** instantiate an invariant on the specified slice */
11891  @Override
11892  protected ModLong_xyz instantiate_dyn(@Prototype ModLong_xyz this, PptSlice slice) {
11893    return new ModLong_xyz (slice);
11894  }
11895
11896  private ModLong_xyz (PptSlice slice) {
11897    super(slice);
11898  }
11899
11900  public @Prototype ModLong_xyz () {
11901    super();
11902  }
11903
11904  private static String[] method_name = new String[] {"", " % ", ""};
11905
11906  @Override
11907  public String[] get_method_name(@GuardSatisfied ModLong_xyz this) {
11908    return method_name;
11909  }
11910
11911  private static int function_id = -1;
11912
11913  @Override
11914  public int get_function_id() {
11915    return function_id;
11916  }
11917
11918  @Override
11919  public void set_function_id(int function_id) {
11920    assert ModLong_xyz.function_id == -1;
11921    ModLong_xyz.function_id = function_id;
11922  }
11923
11924  private static int var_order = 1;
11925
11926  @Override
11927  public int get_var_order(@GuardSatisfied ModLong_xyz this) {
11928    return var_order;
11929  }
11930
11931  @Pure
11932  @Override
11933  public boolean is_symmetric() {
11934
11935      return false;
11936  }
11937
11938  @Override
11939
11940  public long func(long y, long z) {
11941
11942    return (y % z);
11943  }
11944
11945  @Override
11946  public InvariantStatus check_modified(long x, long y,
11947                                      long z, int count) {
11948    return check_ordered(x, y, z, count);
11949  }
11950
11951  @Override
11952  public InvariantStatus add_modified(long x, long y,
11953                                      long z, int count) {
11954    if (Debug.logDetail()) {
11955      log("result=%s, arg1=%s, arg2=%s", x, y, z);
11956    }
11957    return add_ordered(x, y, z, count);
11958  }
11959
11960  @Pure
11961  @Override
11962  public boolean isMod() {
11963    return true;
11964  }
11965
11966  /** Returns a list of non-instantiating suppressions for this invariant. */
11967  @Pure
11968  @Override
11969  public @Nullable NISuppressionSet get_ni_suppressions() {
11970    if (NIS.dkconfig_enabled && dkconfig_enabled) {
11971      return suppressions;
11972    } else {
11973      return null;
11974    }
11975  }
11976
11977  /** definition of this invariant (the suppressee) */
11978  private static NISuppressee suppressee = new NISuppressee(ModLong_xyz.class, 3);
11979
11980  // suppressor definitions (used below)
11981  private static NISuppressor result_eq_arg1 =
11982      new NISuppressor(0, 1, IntEqual.class);
11983  private static NISuppressor result_eq_arg2 =
11984      new NISuppressor(0, 2, IntEqual.class);
11985  private static NISuppressor arg1_eq_arg2 =
11986      new NISuppressor(1, 2, IntEqual.class);
11987
11988  private static NISuppressor result_lt_arg1 =
11989      new NISuppressor(0, 1, IntLessThan.class);
11990  private static NISuppressor result_lt_arg2 =
11991      new NISuppressor(0, 2, IntLessThan.class);
11992  private static NISuppressor arg1_lt_arg2 =
11993      new NISuppressor(1, 2, IntLessThan.class);
11994  private static NISuppressor arg2_lt_arg1 =
11995      new NISuppressor(2, 1, IntLessThan.class);
11996
11997  private static NISuppressor result_le_arg1 =
11998      new NISuppressor(0, 1, IntLessEqual.class);
11999  private static NISuppressor result_le_arg2 =
12000      new NISuppressor(0, 2, IntLessEqual.class);
12001  private static NISuppressor arg1_le_arg2 =
12002      new NISuppressor(1, 2, IntLessEqual.class);
12003  private static NISuppressor arg2_le_arg1 =
12004      new NISuppressor(2, 1, IntLessEqual.class);
12005
12006  private static NISuppressor result_track0_arg1 =
12007      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
12008  private static NISuppressor result_track0_arg2 =
12009      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
12010  private static NISuppressor arg1_track0_arg2 =
12011      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
12012  private static NISuppressor arg1_track0_result =
12013      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
12014  private static NISuppressor arg2_track0_result =
12015      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
12016  private static NISuppressor arg2_track0_arg1 =
12017      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
12018
12019  private static NISuppressor result_eq_1 =
12020      new NISuppressor(0, RangeInt.EqualOne.class);
12021  private static NISuppressor arg1_eq_1 =
12022      new NISuppressor(1, RangeInt.EqualOne.class);
12023  private static NISuppressor arg2_eq_1 =
12024      new NISuppressor(2, RangeInt.EqualOne.class);
12025
12026  private static NISuppressor result_eq_0 =
12027      new NISuppressor(0, RangeInt.EqualZero.class);
12028  private static NISuppressor arg1_eq_0 =
12029      new NISuppressor(1, RangeInt.EqualZero.class);
12030  private static NISuppressor arg2_eq_0 =
12031      new NISuppressor(2, RangeInt.EqualZero.class);
12032
12033  private static NISuppressor result_ne_0 =
12034      new NISuppressor(0, NonZero.class);
12035  private static NISuppressor arg1_ne_0 =
12036      new NISuppressor(1, NonZero.class);
12037  private static NISuppressor arg2_ne_0 =
12038      new NISuppressor(2, NonZero.class);
12039
12040  private static NISuppressor result_ge_0 =
12041      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
12042  private static NISuppressor arg1_ge_0 =
12043      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
12044  private static NISuppressor arg2_ge_0 =
12045      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
12046
12047  private static NISuppressor result_ge_64 =
12048      new NISuppressor(0, RangeInt.GreaterEqual64.class);
12049  private static NISuppressor arg1_ge_64 =
12050      new NISuppressor(1, RangeInt.GreaterEqual64.class);
12051  private static NISuppressor arg2_ge_64 =
12052      new NISuppressor(2, RangeInt.GreaterEqual64.class);
12053
12054  private static NISuppressor result_boolean =
12055      new NISuppressor(0, RangeInt.BooleanVal.class);
12056  private static NISuppressor arg1_boolean =
12057      new NISuppressor(1, RangeInt.BooleanVal.class);
12058  private static NISuppressor arg2_boolean =
12059      new NISuppressor(2, RangeInt.BooleanVal.class);
12060
12061  private static NISuppressor result_even =
12062      new NISuppressor(0, RangeInt.Even.class);
12063  private static NISuppressor arg1_even =
12064      new NISuppressor(1, RangeInt.Even.class);
12065  private static NISuppressor arg2_even =
12066      new NISuppressor(2, RangeInt.Even.class);
12067
12068  private static NISuppressor result_power2 =
12069      new NISuppressor(0, RangeInt.PowerOfTwo.class);
12070  private static NISuppressor arg1_power2 =
12071      new NISuppressor(1, RangeInt.PowerOfTwo.class);
12072  private static NISuppressor arg2_power2 =
12073      new NISuppressor(2, RangeInt.PowerOfTwo.class);
12074
12075  private static NISuppressor result_and0_arg1 =
12076      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
12077  private static NISuppressor result_and0_arg2 =
12078      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
12079  private static NISuppressor arg1_and0_arg2 =
12080      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
12081
12082  // The arguments to bitwise subset are backwards from what one
12083  // might expect.  The second argument is a subset of the first
12084  // argument
12085  private static NISuppressor arg1_bw_subset_arg2 =
12086      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
12087  private static NISuppressor arg2_bw_subset_arg1 =
12088      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
12089
12090  private static NISuppressor result_shift0_arg1 =
12091      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
12092  private static NISuppressor result_shift0_arg2 =
12093      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
12094  private static NISuppressor arg1_shift0_arg2 =
12095      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
12096
12097  private static NISuppressor arg2_divides_arg1 =
12098      new NISuppressor(1, 2, NumericInt.Divides.class);
12099  private static NISuppressor arg1_divides_arg2 =
12100      new NISuppressor(2, 1, NumericInt.Divides.class);
12101
12102  private static NISuppressor arg2_valid_shift =
12103      new NISuppressor(2, RangeInt.Bound0_63.class);
12104
12105    private static NISuppressionSet suppressions =
12106      new NISuppressionSet(
12107          new NISuppression[] {
12108            // anything mod 0 is undefined
12109            // (r == y) && (y < z) && (z != 0) && (r >= 0) ==> r = y % z
12110            new NISuppression(result_eq_arg1, arg1_lt_arg2, arg2_ne_0, result_ge_0, suppressee),
12111
12112            // (r == 0) && ((y % z) == 0)
12113            new NISuppression(result_eq_0, arg2_divides_arg1, suppressee),
12114
12115            // These are unnecessary as the divides invariant handles these
12116            // nicely.
12117            // (r == 0) && (z == 1)      ==> r = y % z
12118            // new NISuppression (result_eq_0, arg2_eq_1, suppressee),
12119
12120            // (r == 0) && (y == z)
12121            // new NISuppression (result_eq_0, arg1_eq_arg2, suppressee),
12122          });
12123
12124  // Create a suppression factory for functionBinary
12125
12126}
12127
12128/**
12129 * Represents the invariant {@code y = Mod(x, z)} over three long
12130 * scalars. 
12131 */
12132public static class ModLong_yxz extends FunctionBinary {
12133  // We are Serializable, so we specify a version to allow changes to
12134  // method signatures without breaking serialization.  If you add or
12135  // remove fields, you should change this number to the current date.
12136  static final long serialVersionUID = 20031030L;
12137
12138  private static @Prototype ModLong_yxz proto = new @Prototype ModLong_yxz ();
12139
12140  /** Returns the prototype invariant for ModLong_yxz */
12141  public static @Prototype ModLong_yxz get_proto() {
12142    return proto;
12143  }
12144
12145  /** instantiate an invariant on the specified slice */
12146  @Override
12147  protected ModLong_yxz instantiate_dyn(@Prototype ModLong_yxz this, PptSlice slice) {
12148    return new ModLong_yxz (slice);
12149  }
12150
12151  private ModLong_yxz (PptSlice slice) {
12152    super(slice);
12153  }
12154
12155  public @Prototype ModLong_yxz () {
12156    super();
12157  }
12158
12159  private static String[] method_name = new String[] {"", " % ", ""};
12160
12161  @Override
12162  public String[] get_method_name(@GuardSatisfied ModLong_yxz this) {
12163    return method_name;
12164  }
12165
12166  private static int function_id = -1;
12167
12168  @Override
12169  public int get_function_id() {
12170    return function_id;
12171  }
12172
12173  @Override
12174  public void set_function_id(int function_id) {
12175    assert ModLong_yxz.function_id == -1;
12176    ModLong_yxz.function_id = function_id;
12177  }
12178
12179  private static int var_order = 2;
12180
12181  @Override
12182  public int get_var_order(@GuardSatisfied ModLong_yxz this) {
12183    return var_order;
12184  }
12185
12186  @Pure
12187  @Override
12188  public boolean is_symmetric() {
12189
12190      return false;
12191  }
12192
12193  @Override
12194
12195  public long func(long x, long z) {
12196
12197    return (x % z);
12198  }
12199
12200  @Override
12201  public InvariantStatus check_modified(long x, long y,
12202                                      long z, int count) {
12203    return check_ordered(y, x, z, count);
12204  }
12205
12206  @Override
12207  public InvariantStatus add_modified(long x, long y,
12208                                      long z, int count) {
12209    if (Debug.logDetail()) {
12210      log("result=%s, arg1=%s, arg2=%s", y, x, z);
12211    }
12212    return add_ordered(y, x, z, count);
12213  }
12214
12215  @Pure
12216  @Override
12217  public boolean isMod() {
12218    return true;
12219  }
12220
12221  /** Returns a list of non-instantiating suppressions for this invariant. */
12222  @Pure
12223  @Override
12224  public @Nullable NISuppressionSet get_ni_suppressions() {
12225    if (NIS.dkconfig_enabled && dkconfig_enabled) {
12226      return suppressions;
12227    } else {
12228      return null;
12229    }
12230  }
12231
12232  /** definition of this invariant (the suppressee) */
12233  private static NISuppressee suppressee = new NISuppressee(ModLong_yxz.class, 3);
12234
12235  // suppressor definitions (used below)
12236  private static NISuppressor result_eq_arg1 =
12237      new NISuppressor(1, 0, IntEqual.class);
12238  private static NISuppressor result_eq_arg2 =
12239      new NISuppressor(1, 2, IntEqual.class);
12240  private static NISuppressor arg1_eq_arg2 =
12241      new NISuppressor(0, 2, IntEqual.class);
12242
12243  private static NISuppressor result_lt_arg1 =
12244      new NISuppressor(1, 0, IntLessThan.class);
12245  private static NISuppressor result_lt_arg2 =
12246      new NISuppressor(1, 2, IntLessThan.class);
12247  private static NISuppressor arg1_lt_arg2 =
12248      new NISuppressor(0, 2, IntLessThan.class);
12249  private static NISuppressor arg2_lt_arg1 =
12250      new NISuppressor(2, 0, IntLessThan.class);
12251
12252  private static NISuppressor result_le_arg1 =
12253      new NISuppressor(1, 0, IntLessEqual.class);
12254  private static NISuppressor result_le_arg2 =
12255      new NISuppressor(1, 2, IntLessEqual.class);
12256  private static NISuppressor arg1_le_arg2 =
12257      new NISuppressor(0, 2, IntLessEqual.class);
12258  private static NISuppressor arg2_le_arg1 =
12259      new NISuppressor(2, 0, IntLessEqual.class);
12260
12261  private static NISuppressor result_track0_arg1 =
12262      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
12263  private static NISuppressor result_track0_arg2 =
12264      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
12265  private static NISuppressor arg1_track0_arg2 =
12266      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
12267  private static NISuppressor arg1_track0_result =
12268      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
12269  private static NISuppressor arg2_track0_result =
12270      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
12271  private static NISuppressor arg2_track0_arg1 =
12272      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
12273
12274  private static NISuppressor result_eq_1 =
12275      new NISuppressor(1, RangeInt.EqualOne.class);
12276  private static NISuppressor arg1_eq_1 =
12277      new NISuppressor(0, RangeInt.EqualOne.class);
12278  private static NISuppressor arg2_eq_1 =
12279      new NISuppressor(2, RangeInt.EqualOne.class);
12280
12281  private static NISuppressor result_eq_0 =
12282      new NISuppressor(1, RangeInt.EqualZero.class);
12283  private static NISuppressor arg1_eq_0 =
12284      new NISuppressor(0, RangeInt.EqualZero.class);
12285  private static NISuppressor arg2_eq_0 =
12286      new NISuppressor(2, RangeInt.EqualZero.class);
12287
12288  private static NISuppressor result_ne_0 =
12289      new NISuppressor(1, NonZero.class);
12290  private static NISuppressor arg1_ne_0 =
12291      new NISuppressor(0, NonZero.class);
12292  private static NISuppressor arg2_ne_0 =
12293      new NISuppressor(2, NonZero.class);
12294
12295  private static NISuppressor result_ge_0 =
12296      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
12297  private static NISuppressor arg1_ge_0 =
12298      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
12299  private static NISuppressor arg2_ge_0 =
12300      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
12301
12302  private static NISuppressor result_ge_64 =
12303      new NISuppressor(1, RangeInt.GreaterEqual64.class);
12304  private static NISuppressor arg1_ge_64 =
12305      new NISuppressor(0, RangeInt.GreaterEqual64.class);
12306  private static NISuppressor arg2_ge_64 =
12307      new NISuppressor(2, RangeInt.GreaterEqual64.class);
12308
12309  private static NISuppressor result_boolean =
12310      new NISuppressor(1, RangeInt.BooleanVal.class);
12311  private static NISuppressor arg1_boolean =
12312      new NISuppressor(0, RangeInt.BooleanVal.class);
12313  private static NISuppressor arg2_boolean =
12314      new NISuppressor(2, RangeInt.BooleanVal.class);
12315
12316  private static NISuppressor result_even =
12317      new NISuppressor(1, RangeInt.Even.class);
12318  private static NISuppressor arg1_even =
12319      new NISuppressor(0, RangeInt.Even.class);
12320  private static NISuppressor arg2_even =
12321      new NISuppressor(2, RangeInt.Even.class);
12322
12323  private static NISuppressor result_power2 =
12324      new NISuppressor(1, RangeInt.PowerOfTwo.class);
12325  private static NISuppressor arg1_power2 =
12326      new NISuppressor(0, RangeInt.PowerOfTwo.class);
12327  private static NISuppressor arg2_power2 =
12328      new NISuppressor(2, RangeInt.PowerOfTwo.class);
12329
12330  private static NISuppressor result_and0_arg1 =
12331      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
12332  private static NISuppressor result_and0_arg2 =
12333      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
12334  private static NISuppressor arg1_and0_arg2 =
12335      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
12336
12337  // The arguments to bitwise subset are backwards from what one
12338  // might expect.  The second argument is a subset of the first
12339  // argument
12340  private static NISuppressor arg1_bw_subset_arg2 =
12341      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
12342  private static NISuppressor arg2_bw_subset_arg1 =
12343      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
12344
12345  private static NISuppressor result_shift0_arg1 =
12346      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
12347  private static NISuppressor result_shift0_arg2 =
12348      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
12349  private static NISuppressor arg1_shift0_arg2 =
12350      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
12351
12352  private static NISuppressor arg2_divides_arg1 =
12353      new NISuppressor(0, 2, NumericInt.Divides.class);
12354  private static NISuppressor arg1_divides_arg2 =
12355      new NISuppressor(2, 0, NumericInt.Divides.class);
12356
12357  private static NISuppressor arg2_valid_shift =
12358      new NISuppressor(2, RangeInt.Bound0_63.class);
12359
12360    private static NISuppressionSet suppressions =
12361      new NISuppressionSet(
12362          new NISuppression[] {
12363            // anything mod 0 is undefined
12364            // (r == x) && (x < z) && (z != 0) && (r >= 0) ==> r = x % z
12365            new NISuppression(result_eq_arg1, arg1_lt_arg2, arg2_ne_0, result_ge_0, suppressee),
12366
12367            // (r == 0) && ((x % z) == 0)
12368            new NISuppression(result_eq_0, arg2_divides_arg1, suppressee),
12369
12370            // These are unnecessary as the divides invariant handles these
12371            // nicely.
12372            // (r == 0) && (z == 1)      ==> r = x % z
12373            // new NISuppression (result_eq_0, arg2_eq_1, suppressee),
12374
12375            // (r == 0) && (x == z)
12376            // new NISuppression (result_eq_0, arg1_eq_arg2, suppressee),
12377          });
12378
12379  // Create a suppression factory for functionBinary
12380
12381}
12382
12383/**
12384 * Represents the invariant {@code z = Mod(x, y)} over three long
12385 * scalars. 
12386 */
12387public static class ModLong_zxy extends FunctionBinary {
12388  // We are Serializable, so we specify a version to allow changes to
12389  // method signatures without breaking serialization.  If you add or
12390  // remove fields, you should change this number to the current date.
12391  static final long serialVersionUID = 20031030L;
12392
12393  private static @Prototype ModLong_zxy proto = new @Prototype ModLong_zxy ();
12394
12395  /** Returns the prototype invariant for ModLong_zxy */
12396  public static @Prototype ModLong_zxy get_proto() {
12397    return proto;
12398  }
12399
12400  /** instantiate an invariant on the specified slice */
12401  @Override
12402  protected ModLong_zxy instantiate_dyn(@Prototype ModLong_zxy this, PptSlice slice) {
12403    return new ModLong_zxy (slice);
12404  }
12405
12406  private ModLong_zxy (PptSlice slice) {
12407    super(slice);
12408  }
12409
12410  public @Prototype ModLong_zxy () {
12411    super();
12412  }
12413
12414  private static String[] method_name = new String[] {"", " % ", ""};
12415
12416  @Override
12417  public String[] get_method_name(@GuardSatisfied ModLong_zxy this) {
12418    return method_name;
12419  }
12420
12421  private static int function_id = -1;
12422
12423  @Override
12424  public int get_function_id() {
12425    return function_id;
12426  }
12427
12428  @Override
12429  public void set_function_id(int function_id) {
12430    assert ModLong_zxy.function_id == -1;
12431    ModLong_zxy.function_id = function_id;
12432  }
12433
12434  private static int var_order = 3;
12435
12436  @Override
12437  public int get_var_order(@GuardSatisfied ModLong_zxy this) {
12438    return var_order;
12439  }
12440
12441  @Pure
12442  @Override
12443  public boolean is_symmetric() {
12444
12445      return false;
12446  }
12447
12448  @Override
12449
12450  public long func(long x, long y) {
12451
12452    return (x % y);
12453  }
12454
12455  @Override
12456  public InvariantStatus check_modified(long x, long y,
12457                                      long z, int count) {
12458    return check_ordered(z, x, y, count);
12459  }
12460
12461  @Override
12462  public InvariantStatus add_modified(long x, long y,
12463                                      long z, int count) {
12464    if (Debug.logDetail()) {
12465      log("result=%s, arg1=%s, arg2=%s", z, x, y);
12466    }
12467    return add_ordered(z, x, y, count);
12468  }
12469
12470  @Pure
12471  @Override
12472  public boolean isMod() {
12473    return true;
12474  }
12475
12476  /** Returns a list of non-instantiating suppressions for this invariant. */
12477  @Pure
12478  @Override
12479  public @Nullable NISuppressionSet get_ni_suppressions() {
12480    if (NIS.dkconfig_enabled && dkconfig_enabled) {
12481      return suppressions;
12482    } else {
12483      return null;
12484    }
12485  }
12486
12487  /** definition of this invariant (the suppressee) */
12488  private static NISuppressee suppressee = new NISuppressee(ModLong_zxy.class, 3);
12489
12490  // suppressor definitions (used below)
12491  private static NISuppressor result_eq_arg1 =
12492      new NISuppressor(2, 0, IntEqual.class);
12493  private static NISuppressor result_eq_arg2 =
12494      new NISuppressor(2, 1, IntEqual.class);
12495  private static NISuppressor arg1_eq_arg2 =
12496      new NISuppressor(0, 1, IntEqual.class);
12497
12498  private static NISuppressor result_lt_arg1 =
12499      new NISuppressor(2, 0, IntLessThan.class);
12500  private static NISuppressor result_lt_arg2 =
12501      new NISuppressor(2, 1, IntLessThan.class);
12502  private static NISuppressor arg1_lt_arg2 =
12503      new NISuppressor(0, 1, IntLessThan.class);
12504  private static NISuppressor arg2_lt_arg1 =
12505      new NISuppressor(1, 0, IntLessThan.class);
12506
12507  private static NISuppressor result_le_arg1 =
12508      new NISuppressor(2, 0, IntLessEqual.class);
12509  private static NISuppressor result_le_arg2 =
12510      new NISuppressor(2, 1, IntLessEqual.class);
12511  private static NISuppressor arg1_le_arg2 =
12512      new NISuppressor(0, 1, IntLessEqual.class);
12513  private static NISuppressor arg2_le_arg1 =
12514      new NISuppressor(1, 0, IntLessEqual.class);
12515
12516  private static NISuppressor result_track0_arg1 =
12517      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
12518  private static NISuppressor result_track0_arg2 =
12519      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
12520  private static NISuppressor arg1_track0_arg2 =
12521      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
12522  private static NISuppressor arg1_track0_result =
12523      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
12524  private static NISuppressor arg2_track0_result =
12525      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
12526  private static NISuppressor arg2_track0_arg1 =
12527      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
12528
12529  private static NISuppressor result_eq_1 =
12530      new NISuppressor(2, RangeInt.EqualOne.class);
12531  private static NISuppressor arg1_eq_1 =
12532      new NISuppressor(0, RangeInt.EqualOne.class);
12533  private static NISuppressor arg2_eq_1 =
12534      new NISuppressor(1, RangeInt.EqualOne.class);
12535
12536  private static NISuppressor result_eq_0 =
12537      new NISuppressor(2, RangeInt.EqualZero.class);
12538  private static NISuppressor arg1_eq_0 =
12539      new NISuppressor(0, RangeInt.EqualZero.class);
12540  private static NISuppressor arg2_eq_0 =
12541      new NISuppressor(1, RangeInt.EqualZero.class);
12542
12543  private static NISuppressor result_ne_0 =
12544      new NISuppressor(2, NonZero.class);
12545  private static NISuppressor arg1_ne_0 =
12546      new NISuppressor(0, NonZero.class);
12547  private static NISuppressor arg2_ne_0 =
12548      new NISuppressor(1, NonZero.class);
12549
12550  private static NISuppressor result_ge_0 =
12551      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
12552  private static NISuppressor arg1_ge_0 =
12553      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
12554  private static NISuppressor arg2_ge_0 =
12555      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
12556
12557  private static NISuppressor result_ge_64 =
12558      new NISuppressor(2, RangeInt.GreaterEqual64.class);
12559  private static NISuppressor arg1_ge_64 =
12560      new NISuppressor(0, RangeInt.GreaterEqual64.class);
12561  private static NISuppressor arg2_ge_64 =
12562      new NISuppressor(1, RangeInt.GreaterEqual64.class);
12563
12564  private static NISuppressor result_boolean =
12565      new NISuppressor(2, RangeInt.BooleanVal.class);
12566  private static NISuppressor arg1_boolean =
12567      new NISuppressor(0, RangeInt.BooleanVal.class);
12568  private static NISuppressor arg2_boolean =
12569      new NISuppressor(1, RangeInt.BooleanVal.class);
12570
12571  private static NISuppressor result_even =
12572      new NISuppressor(2, RangeInt.Even.class);
12573  private static NISuppressor arg1_even =
12574      new NISuppressor(0, RangeInt.Even.class);
12575  private static NISuppressor arg2_even =
12576      new NISuppressor(1, RangeInt.Even.class);
12577
12578  private static NISuppressor result_power2 =
12579      new NISuppressor(2, RangeInt.PowerOfTwo.class);
12580  private static NISuppressor arg1_power2 =
12581      new NISuppressor(0, RangeInt.PowerOfTwo.class);
12582  private static NISuppressor arg2_power2 =
12583      new NISuppressor(1, RangeInt.PowerOfTwo.class);
12584
12585  private static NISuppressor result_and0_arg1 =
12586      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
12587  private static NISuppressor result_and0_arg2 =
12588      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
12589  private static NISuppressor arg1_and0_arg2 =
12590      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
12591
12592  // The arguments to bitwise subset are backwards from what one
12593  // might expect.  The second argument is a subset of the first
12594  // argument
12595  private static NISuppressor arg1_bw_subset_arg2 =
12596      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
12597  private static NISuppressor arg2_bw_subset_arg1 =
12598      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
12599
12600  private static NISuppressor result_shift0_arg1 =
12601      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
12602  private static NISuppressor result_shift0_arg2 =
12603      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
12604  private static NISuppressor arg1_shift0_arg2 =
12605      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
12606
12607  private static NISuppressor arg2_divides_arg1 =
12608      new NISuppressor(0, 1, NumericInt.Divides.class);
12609  private static NISuppressor arg1_divides_arg2 =
12610      new NISuppressor(1, 0, NumericInt.Divides.class);
12611
12612  private static NISuppressor arg2_valid_shift =
12613      new NISuppressor(1, RangeInt.Bound0_63.class);
12614
12615    private static NISuppressionSet suppressions =
12616      new NISuppressionSet(
12617          new NISuppression[] {
12618            // anything mod 0 is undefined
12619            // (r == x) && (x < y) && (y != 0) && (r >= 0) ==> r = x % y
12620            new NISuppression(result_eq_arg1, arg1_lt_arg2, arg2_ne_0, result_ge_0, suppressee),
12621
12622            // (r == 0) && ((x % y) == 0)
12623            new NISuppression(result_eq_0, arg2_divides_arg1, suppressee),
12624
12625            // These are unnecessary as the divides invariant handles these
12626            // nicely.
12627            // (r == 0) && (y == 1)      ==> r = x % y
12628            // new NISuppression (result_eq_0, arg2_eq_1, suppressee),
12629
12630            // (r == 0) && (x == y)
12631            // new NISuppression (result_eq_0, arg1_eq_arg2, suppressee),
12632          });
12633
12634  // Create a suppression factory for functionBinary
12635
12636}
12637
12638/**
12639 * Represents the invariant {@code x = Mod(z, y)} over three long
12640 * scalars. 
12641 */
12642public static class ModLong_xzy extends FunctionBinary {
12643  // We are Serializable, so we specify a version to allow changes to
12644  // method signatures without breaking serialization.  If you add or
12645  // remove fields, you should change this number to the current date.
12646  static final long serialVersionUID = 20031030L;
12647
12648  private static @Prototype ModLong_xzy proto = new @Prototype ModLong_xzy ();
12649
12650  /** Returns the prototype invariant for ModLong_xzy */
12651  public static @Prototype ModLong_xzy get_proto() {
12652    return proto;
12653  }
12654
12655  /** instantiate an invariant on the specified slice */
12656  @Override
12657  protected ModLong_xzy instantiate_dyn(@Prototype ModLong_xzy this, PptSlice slice) {
12658    return new ModLong_xzy (slice);
12659  }
12660
12661  private ModLong_xzy (PptSlice slice) {
12662    super(slice);
12663  }
12664
12665  public @Prototype ModLong_xzy () {
12666    super();
12667  }
12668
12669  private static String[] method_name = new String[] {"", " % ", ""};
12670
12671  @Override
12672  public String[] get_method_name(@GuardSatisfied ModLong_xzy this) {
12673    return method_name;
12674  }
12675
12676  private static int function_id = -1;
12677
12678  @Override
12679  public int get_function_id() {
12680    return function_id;
12681  }
12682
12683  @Override
12684  public void set_function_id(int function_id) {
12685    assert ModLong_xzy.function_id == -1;
12686    ModLong_xzy.function_id = function_id;
12687  }
12688
12689  private static int var_order = 4;
12690
12691  @Override
12692  public int get_var_order(@GuardSatisfied ModLong_xzy this) {
12693    return var_order;
12694  }
12695
12696  @Pure
12697  @Override
12698  public boolean is_symmetric() {
12699
12700      return false;
12701  }
12702
12703  @Override
12704
12705  public long func(long z, long y) {
12706
12707    return (z % y);
12708  }
12709
12710  @Override
12711  public InvariantStatus check_modified(long x, long y,
12712                                      long z, int count) {
12713    return check_ordered(x, z, y, count);
12714  }
12715
12716  @Override
12717  public InvariantStatus add_modified(long x, long y,
12718                                      long z, int count) {
12719    if (Debug.logDetail()) {
12720      log("result=%s, arg1=%s, arg2=%s", x, z, y);
12721    }
12722    return add_ordered(x, z, y, count);
12723  }
12724
12725  @Pure
12726  @Override
12727  public boolean isMod() {
12728    return true;
12729  }
12730
12731  /** Returns a list of non-instantiating suppressions for this invariant. */
12732  @Pure
12733  @Override
12734  public @Nullable NISuppressionSet get_ni_suppressions() {
12735    if (NIS.dkconfig_enabled && dkconfig_enabled) {
12736      return suppressions;
12737    } else {
12738      return null;
12739    }
12740  }
12741
12742  /** definition of this invariant (the suppressee) */
12743  private static NISuppressee suppressee = new NISuppressee(ModLong_xzy.class, 3);
12744
12745  // suppressor definitions (used below)
12746  private static NISuppressor result_eq_arg1 =
12747      new NISuppressor(0, 2, IntEqual.class);
12748  private static NISuppressor result_eq_arg2 =
12749      new NISuppressor(0, 1, IntEqual.class);
12750  private static NISuppressor arg1_eq_arg2 =
12751      new NISuppressor(2, 1, IntEqual.class);
12752
12753  private static NISuppressor result_lt_arg1 =
12754      new NISuppressor(0, 2, IntLessThan.class);
12755  private static NISuppressor result_lt_arg2 =
12756      new NISuppressor(0, 1, IntLessThan.class);
12757  private static NISuppressor arg1_lt_arg2 =
12758      new NISuppressor(2, 1, IntLessThan.class);
12759  private static NISuppressor arg2_lt_arg1 =
12760      new NISuppressor(1, 2, IntLessThan.class);
12761
12762  private static NISuppressor result_le_arg1 =
12763      new NISuppressor(0, 2, IntLessEqual.class);
12764  private static NISuppressor result_le_arg2 =
12765      new NISuppressor(0, 1, IntLessEqual.class);
12766  private static NISuppressor arg1_le_arg2 =
12767      new NISuppressor(2, 1, IntLessEqual.class);
12768  private static NISuppressor arg2_le_arg1 =
12769      new NISuppressor(1, 2, IntLessEqual.class);
12770
12771  private static NISuppressor result_track0_arg1 =
12772      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
12773  private static NISuppressor result_track0_arg2 =
12774      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
12775  private static NISuppressor arg1_track0_arg2 =
12776      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
12777  private static NISuppressor arg1_track0_result =
12778      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
12779  private static NISuppressor arg2_track0_result =
12780      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
12781  private static NISuppressor arg2_track0_arg1 =
12782      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
12783
12784  private static NISuppressor result_eq_1 =
12785      new NISuppressor(0, RangeInt.EqualOne.class);
12786  private static NISuppressor arg1_eq_1 =
12787      new NISuppressor(2, RangeInt.EqualOne.class);
12788  private static NISuppressor arg2_eq_1 =
12789      new NISuppressor(1, RangeInt.EqualOne.class);
12790
12791  private static NISuppressor result_eq_0 =
12792      new NISuppressor(0, RangeInt.EqualZero.class);
12793  private static NISuppressor arg1_eq_0 =
12794      new NISuppressor(2, RangeInt.EqualZero.class);
12795  private static NISuppressor arg2_eq_0 =
12796      new NISuppressor(1, RangeInt.EqualZero.class);
12797
12798  private static NISuppressor result_ne_0 =
12799      new NISuppressor(0, NonZero.class);
12800  private static NISuppressor arg1_ne_0 =
12801      new NISuppressor(2, NonZero.class);
12802  private static NISuppressor arg2_ne_0 =
12803      new NISuppressor(1, NonZero.class);
12804
12805  private static NISuppressor result_ge_0 =
12806      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
12807  private static NISuppressor arg1_ge_0 =
12808      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
12809  private static NISuppressor arg2_ge_0 =
12810      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
12811
12812  private static NISuppressor result_ge_64 =
12813      new NISuppressor(0, RangeInt.GreaterEqual64.class);
12814  private static NISuppressor arg1_ge_64 =
12815      new NISuppressor(2, RangeInt.GreaterEqual64.class);
12816  private static NISuppressor arg2_ge_64 =
12817      new NISuppressor(1, RangeInt.GreaterEqual64.class);
12818
12819  private static NISuppressor result_boolean =
12820      new NISuppressor(0, RangeInt.BooleanVal.class);
12821  private static NISuppressor arg1_boolean =
12822      new NISuppressor(2, RangeInt.BooleanVal.class);
12823  private static NISuppressor arg2_boolean =
12824      new NISuppressor(1, RangeInt.BooleanVal.class);
12825
12826  private static NISuppressor result_even =
12827      new NISuppressor(0, RangeInt.Even.class);
12828  private static NISuppressor arg1_even =
12829      new NISuppressor(2, RangeInt.Even.class);
12830  private static NISuppressor arg2_even =
12831      new NISuppressor(1, RangeInt.Even.class);
12832
12833  private static NISuppressor result_power2 =
12834      new NISuppressor(0, RangeInt.PowerOfTwo.class);
12835  private static NISuppressor arg1_power2 =
12836      new NISuppressor(2, RangeInt.PowerOfTwo.class);
12837  private static NISuppressor arg2_power2 =
12838      new NISuppressor(1, RangeInt.PowerOfTwo.class);
12839
12840  private static NISuppressor result_and0_arg1 =
12841      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
12842  private static NISuppressor result_and0_arg2 =
12843      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
12844  private static NISuppressor arg1_and0_arg2 =
12845      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
12846
12847  // The arguments to bitwise subset are backwards from what one
12848  // might expect.  The second argument is a subset of the first
12849  // argument
12850  private static NISuppressor arg1_bw_subset_arg2 =
12851      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
12852  private static NISuppressor arg2_bw_subset_arg1 =
12853      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
12854
12855  private static NISuppressor result_shift0_arg1 =
12856      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
12857  private static NISuppressor result_shift0_arg2 =
12858      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
12859  private static NISuppressor arg1_shift0_arg2 =
12860      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
12861
12862  private static NISuppressor arg2_divides_arg1 =
12863      new NISuppressor(2, 1, NumericInt.Divides.class);
12864  private static NISuppressor arg1_divides_arg2 =
12865      new NISuppressor(1, 2, NumericInt.Divides.class);
12866
12867  private static NISuppressor arg2_valid_shift =
12868      new NISuppressor(1, RangeInt.Bound0_63.class);
12869
12870    private static NISuppressionSet suppressions =
12871      new NISuppressionSet(
12872          new NISuppression[] {
12873            // anything mod 0 is undefined
12874            // (r == z) && (z < y) && (y != 0) && (r >= 0) ==> r = z % y
12875            new NISuppression(result_eq_arg1, arg1_lt_arg2, arg2_ne_0, result_ge_0, suppressee),
12876
12877            // (r == 0) && ((z % y) == 0)
12878            new NISuppression(result_eq_0, arg2_divides_arg1, suppressee),
12879
12880            // These are unnecessary as the divides invariant handles these
12881            // nicely.
12882            // (r == 0) && (y == 1)      ==> r = z % y
12883            // new NISuppression (result_eq_0, arg2_eq_1, suppressee),
12884
12885            // (r == 0) && (z == y)
12886            // new NISuppression (result_eq_0, arg1_eq_arg2, suppressee),
12887          });
12888
12889  // Create a suppression factory for functionBinary
12890
12891}
12892
12893/**
12894 * Represents the invariant {@code y = Mod(z, x)} over three long
12895 * scalars. 
12896 */
12897public static class ModLong_yzx extends FunctionBinary {
12898  // We are Serializable, so we specify a version to allow changes to
12899  // method signatures without breaking serialization.  If you add or
12900  // remove fields, you should change this number to the current date.
12901  static final long serialVersionUID = 20031030L;
12902
12903  private static @Prototype ModLong_yzx proto = new @Prototype ModLong_yzx ();
12904
12905  /** Returns the prototype invariant for ModLong_yzx */
12906  public static @Prototype ModLong_yzx get_proto() {
12907    return proto;
12908  }
12909
12910  /** instantiate an invariant on the specified slice */
12911  @Override
12912  protected ModLong_yzx instantiate_dyn(@Prototype ModLong_yzx this, PptSlice slice) {
12913    return new ModLong_yzx (slice);
12914  }
12915
12916  private ModLong_yzx (PptSlice slice) {
12917    super(slice);
12918  }
12919
12920  public @Prototype ModLong_yzx () {
12921    super();
12922  }
12923
12924  private static String[] method_name = new String[] {"", " % ", ""};
12925
12926  @Override
12927  public String[] get_method_name(@GuardSatisfied ModLong_yzx this) {
12928    return method_name;
12929  }
12930
12931  private static int function_id = -1;
12932
12933  @Override
12934  public int get_function_id() {
12935    return function_id;
12936  }
12937
12938  @Override
12939  public void set_function_id(int function_id) {
12940    assert ModLong_yzx.function_id == -1;
12941    ModLong_yzx.function_id = function_id;
12942  }
12943
12944  private static int var_order = 5;
12945
12946  @Override
12947  public int get_var_order(@GuardSatisfied ModLong_yzx this) {
12948    return var_order;
12949  }
12950
12951  @Pure
12952  @Override
12953  public boolean is_symmetric() {
12954
12955      return false;
12956  }
12957
12958  @Override
12959
12960  public long func(long z, long x) {
12961
12962    return (z % x);
12963  }
12964
12965  @Override
12966  public InvariantStatus check_modified(long x, long y,
12967                                      long z, int count) {
12968    return check_ordered(y, z, x, count);
12969  }
12970
12971  @Override
12972  public InvariantStatus add_modified(long x, long y,
12973                                      long z, int count) {
12974    if (Debug.logDetail()) {
12975      log("result=%s, arg1=%s, arg2=%s", y, z, x);
12976    }
12977    return add_ordered(y, z, x, count);
12978  }
12979
12980  @Pure
12981  @Override
12982  public boolean isMod() {
12983    return true;
12984  }
12985
12986  /** Returns a list of non-instantiating suppressions for this invariant. */
12987  @Pure
12988  @Override
12989  public @Nullable NISuppressionSet get_ni_suppressions() {
12990    if (NIS.dkconfig_enabled && dkconfig_enabled) {
12991      return suppressions;
12992    } else {
12993      return null;
12994    }
12995  }
12996
12997  /** definition of this invariant (the suppressee) */
12998  private static NISuppressee suppressee = new NISuppressee(ModLong_yzx.class, 3);
12999
13000  // suppressor definitions (used below)
13001  private static NISuppressor result_eq_arg1 =
13002      new NISuppressor(1, 2, IntEqual.class);
13003  private static NISuppressor result_eq_arg2 =
13004      new NISuppressor(1, 0, IntEqual.class);
13005  private static NISuppressor arg1_eq_arg2 =
13006      new NISuppressor(2, 0, IntEqual.class);
13007
13008  private static NISuppressor result_lt_arg1 =
13009      new NISuppressor(1, 2, IntLessThan.class);
13010  private static NISuppressor result_lt_arg2 =
13011      new NISuppressor(1, 0, IntLessThan.class);
13012  private static NISuppressor arg1_lt_arg2 =
13013      new NISuppressor(2, 0, IntLessThan.class);
13014  private static NISuppressor arg2_lt_arg1 =
13015      new NISuppressor(0, 2, IntLessThan.class);
13016
13017  private static NISuppressor result_le_arg1 =
13018      new NISuppressor(1, 2, IntLessEqual.class);
13019  private static NISuppressor result_le_arg2 =
13020      new NISuppressor(1, 0, IntLessEqual.class);
13021  private static NISuppressor arg1_le_arg2 =
13022      new NISuppressor(2, 0, IntLessEqual.class);
13023  private static NISuppressor arg2_le_arg1 =
13024      new NISuppressor(0, 2, IntLessEqual.class);
13025
13026  private static NISuppressor result_track0_arg1 =
13027      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
13028  private static NISuppressor result_track0_arg2 =
13029      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
13030  private static NISuppressor arg1_track0_arg2 =
13031      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
13032  private static NISuppressor arg1_track0_result =
13033      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
13034  private static NISuppressor arg2_track0_result =
13035      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
13036  private static NISuppressor arg2_track0_arg1 =
13037      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
13038
13039  private static NISuppressor result_eq_1 =
13040      new NISuppressor(1, RangeInt.EqualOne.class);
13041  private static NISuppressor arg1_eq_1 =
13042      new NISuppressor(2, RangeInt.EqualOne.class);
13043  private static NISuppressor arg2_eq_1 =
13044      new NISuppressor(0, RangeInt.EqualOne.class);
13045
13046  private static NISuppressor result_eq_0 =
13047      new NISuppressor(1, RangeInt.EqualZero.class);
13048  private static NISuppressor arg1_eq_0 =
13049      new NISuppressor(2, RangeInt.EqualZero.class);
13050  private static NISuppressor arg2_eq_0 =
13051      new NISuppressor(0, RangeInt.EqualZero.class);
13052
13053  private static NISuppressor result_ne_0 =
13054      new NISuppressor(1, NonZero.class);
13055  private static NISuppressor arg1_ne_0 =
13056      new NISuppressor(2, NonZero.class);
13057  private static NISuppressor arg2_ne_0 =
13058      new NISuppressor(0, NonZero.class);
13059
13060  private static NISuppressor result_ge_0 =
13061      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
13062  private static NISuppressor arg1_ge_0 =
13063      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
13064  private static NISuppressor arg2_ge_0 =
13065      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
13066
13067  private static NISuppressor result_ge_64 =
13068      new NISuppressor(1, RangeInt.GreaterEqual64.class);
13069  private static NISuppressor arg1_ge_64 =
13070      new NISuppressor(2, RangeInt.GreaterEqual64.class);
13071  private static NISuppressor arg2_ge_64 =
13072      new NISuppressor(0, RangeInt.GreaterEqual64.class);
13073
13074  private static NISuppressor result_boolean =
13075      new NISuppressor(1, RangeInt.BooleanVal.class);
13076  private static NISuppressor arg1_boolean =
13077      new NISuppressor(2, RangeInt.BooleanVal.class);
13078  private static NISuppressor arg2_boolean =
13079      new NISuppressor(0, RangeInt.BooleanVal.class);
13080
13081  private static NISuppressor result_even =
13082      new NISuppressor(1, RangeInt.Even.class);
13083  private static NISuppressor arg1_even =
13084      new NISuppressor(2, RangeInt.Even.class);
13085  private static NISuppressor arg2_even =
13086      new NISuppressor(0, RangeInt.Even.class);
13087
13088  private static NISuppressor result_power2 =
13089      new NISuppressor(1, RangeInt.PowerOfTwo.class);
13090  private static NISuppressor arg1_power2 =
13091      new NISuppressor(2, RangeInt.PowerOfTwo.class);
13092  private static NISuppressor arg2_power2 =
13093      new NISuppressor(0, RangeInt.PowerOfTwo.class);
13094
13095  private static NISuppressor result_and0_arg1 =
13096      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
13097  private static NISuppressor result_and0_arg2 =
13098      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
13099  private static NISuppressor arg1_and0_arg2 =
13100      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
13101
13102  // The arguments to bitwise subset are backwards from what one
13103  // might expect.  The second argument is a subset of the first
13104  // argument
13105  private static NISuppressor arg1_bw_subset_arg2 =
13106      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
13107  private static NISuppressor arg2_bw_subset_arg1 =
13108      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
13109
13110  private static NISuppressor result_shift0_arg1 =
13111      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
13112  private static NISuppressor result_shift0_arg2 =
13113      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
13114  private static NISuppressor arg1_shift0_arg2 =
13115      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
13116
13117  private static NISuppressor arg2_divides_arg1 =
13118      new NISuppressor(2, 0, NumericInt.Divides.class);
13119  private static NISuppressor arg1_divides_arg2 =
13120      new NISuppressor(0, 2, NumericInt.Divides.class);
13121
13122  private static NISuppressor arg2_valid_shift =
13123      new NISuppressor(0, RangeInt.Bound0_63.class);
13124
13125    private static NISuppressionSet suppressions =
13126      new NISuppressionSet(
13127          new NISuppression[] {
13128            // anything mod 0 is undefined
13129            // (r == z) && (z < x) && (x != 0) && (r >= 0) ==> r = z % x
13130            new NISuppression(result_eq_arg1, arg1_lt_arg2, arg2_ne_0, result_ge_0, suppressee),
13131
13132            // (r == 0) && ((z % x) == 0)
13133            new NISuppression(result_eq_0, arg2_divides_arg1, suppressee),
13134
13135            // These are unnecessary as the divides invariant handles these
13136            // nicely.
13137            // (r == 0) && (x == 1)      ==> r = z % x
13138            // new NISuppression (result_eq_0, arg2_eq_1, suppressee),
13139
13140            // (r == 0) && (z == x)
13141            // new NISuppression (result_eq_0, arg1_eq_arg2, suppressee),
13142          });
13143
13144  // Create a suppression factory for functionBinary
13145
13146}
13147
13148/**
13149 * Represents the invariant {@code z = Mod(y, x)} over three long
13150 * scalars. 
13151 */
13152public static class ModLong_zyx extends FunctionBinary {
13153  // We are Serializable, so we specify a version to allow changes to
13154  // method signatures without breaking serialization.  If you add or
13155  // remove fields, you should change this number to the current date.
13156  static final long serialVersionUID = 20031030L;
13157
13158  private static @Prototype ModLong_zyx proto = new @Prototype ModLong_zyx ();
13159
13160  /** Returns the prototype invariant for ModLong_zyx */
13161  public static @Prototype ModLong_zyx get_proto() {
13162    return proto;
13163  }
13164
13165  /** instantiate an invariant on the specified slice */
13166  @Override
13167  protected ModLong_zyx instantiate_dyn(@Prototype ModLong_zyx this, PptSlice slice) {
13168    return new ModLong_zyx (slice);
13169  }
13170
13171  private ModLong_zyx (PptSlice slice) {
13172    super(slice);
13173  }
13174
13175  public @Prototype ModLong_zyx () {
13176    super();
13177  }
13178
13179  private static String[] method_name = new String[] {"", " % ", ""};
13180
13181  @Override
13182  public String[] get_method_name(@GuardSatisfied ModLong_zyx this) {
13183    return method_name;
13184  }
13185
13186  private static int function_id = -1;
13187
13188  @Override
13189  public int get_function_id() {
13190    return function_id;
13191  }
13192
13193  @Override
13194  public void set_function_id(int function_id) {
13195    assert ModLong_zyx.function_id == -1;
13196    ModLong_zyx.function_id = function_id;
13197  }
13198
13199  private static int var_order = 6;
13200
13201  @Override
13202  public int get_var_order(@GuardSatisfied ModLong_zyx this) {
13203    return var_order;
13204  }
13205
13206  @Pure
13207  @Override
13208  public boolean is_symmetric() {
13209
13210      return false;
13211  }
13212
13213  @Override
13214
13215  public long func(long y, long x) {
13216
13217    return (y % x);
13218  }
13219
13220  @Override
13221  public InvariantStatus check_modified(long x, long y,
13222                                      long z, int count) {
13223    return check_ordered(z, y, x, count);
13224  }
13225
13226  @Override
13227  public InvariantStatus add_modified(long x, long y,
13228                                      long z, int count) {
13229    if (Debug.logDetail()) {
13230      log("result=%s, arg1=%s, arg2=%s", z, y, x);
13231    }
13232    return add_ordered(z, y, x, count);
13233  }
13234
13235  @Pure
13236  @Override
13237  public boolean isMod() {
13238    return true;
13239  }
13240
13241  /** Returns a list of non-instantiating suppressions for this invariant. */
13242  @Pure
13243  @Override
13244  public @Nullable NISuppressionSet get_ni_suppressions() {
13245    if (NIS.dkconfig_enabled && dkconfig_enabled) {
13246      return suppressions;
13247    } else {
13248      return null;
13249    }
13250  }
13251
13252  /** definition of this invariant (the suppressee) */
13253  private static NISuppressee suppressee = new NISuppressee(ModLong_zyx.class, 3);
13254
13255  // suppressor definitions (used below)
13256  private static NISuppressor result_eq_arg1 =
13257      new NISuppressor(2, 1, IntEqual.class);
13258  private static NISuppressor result_eq_arg2 =
13259      new NISuppressor(2, 0, IntEqual.class);
13260  private static NISuppressor arg1_eq_arg2 =
13261      new NISuppressor(1, 0, IntEqual.class);
13262
13263  private static NISuppressor result_lt_arg1 =
13264      new NISuppressor(2, 1, IntLessThan.class);
13265  private static NISuppressor result_lt_arg2 =
13266      new NISuppressor(2, 0, IntLessThan.class);
13267  private static NISuppressor arg1_lt_arg2 =
13268      new NISuppressor(1, 0, IntLessThan.class);
13269  private static NISuppressor arg2_lt_arg1 =
13270      new NISuppressor(0, 1, IntLessThan.class);
13271
13272  private static NISuppressor result_le_arg1 =
13273      new NISuppressor(2, 1, IntLessEqual.class);
13274  private static NISuppressor result_le_arg2 =
13275      new NISuppressor(2, 0, IntLessEqual.class);
13276  private static NISuppressor arg1_le_arg2 =
13277      new NISuppressor(1, 0, IntLessEqual.class);
13278  private static NISuppressor arg2_le_arg1 =
13279      new NISuppressor(0, 1, IntLessEqual.class);
13280
13281  private static NISuppressor result_track0_arg1 =
13282      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
13283  private static NISuppressor result_track0_arg2 =
13284      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
13285  private static NISuppressor arg1_track0_arg2 =
13286      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
13287  private static NISuppressor arg1_track0_result =
13288      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
13289  private static NISuppressor arg2_track0_result =
13290      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
13291  private static NISuppressor arg2_track0_arg1 =
13292      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
13293
13294  private static NISuppressor result_eq_1 =
13295      new NISuppressor(2, RangeInt.EqualOne.class);
13296  private static NISuppressor arg1_eq_1 =
13297      new NISuppressor(1, RangeInt.EqualOne.class);
13298  private static NISuppressor arg2_eq_1 =
13299      new NISuppressor(0, RangeInt.EqualOne.class);
13300
13301  private static NISuppressor result_eq_0 =
13302      new NISuppressor(2, RangeInt.EqualZero.class);
13303  private static NISuppressor arg1_eq_0 =
13304      new NISuppressor(1, RangeInt.EqualZero.class);
13305  private static NISuppressor arg2_eq_0 =
13306      new NISuppressor(0, RangeInt.EqualZero.class);
13307
13308  private static NISuppressor result_ne_0 =
13309      new NISuppressor(2, NonZero.class);
13310  private static NISuppressor arg1_ne_0 =
13311      new NISuppressor(1, NonZero.class);
13312  private static NISuppressor arg2_ne_0 =
13313      new NISuppressor(0, NonZero.class);
13314
13315  private static NISuppressor result_ge_0 =
13316      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
13317  private static NISuppressor arg1_ge_0 =
13318      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
13319  private static NISuppressor arg2_ge_0 =
13320      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
13321
13322  private static NISuppressor result_ge_64 =
13323      new NISuppressor(2, RangeInt.GreaterEqual64.class);
13324  private static NISuppressor arg1_ge_64 =
13325      new NISuppressor(1, RangeInt.GreaterEqual64.class);
13326  private static NISuppressor arg2_ge_64 =
13327      new NISuppressor(0, RangeInt.GreaterEqual64.class);
13328
13329  private static NISuppressor result_boolean =
13330      new NISuppressor(2, RangeInt.BooleanVal.class);
13331  private static NISuppressor arg1_boolean =
13332      new NISuppressor(1, RangeInt.BooleanVal.class);
13333  private static NISuppressor arg2_boolean =
13334      new NISuppressor(0, RangeInt.BooleanVal.class);
13335
13336  private static NISuppressor result_even =
13337      new NISuppressor(2, RangeInt.Even.class);
13338  private static NISuppressor arg1_even =
13339      new NISuppressor(1, RangeInt.Even.class);
13340  private static NISuppressor arg2_even =
13341      new NISuppressor(0, RangeInt.Even.class);
13342
13343  private static NISuppressor result_power2 =
13344      new NISuppressor(2, RangeInt.PowerOfTwo.class);
13345  private static NISuppressor arg1_power2 =
13346      new NISuppressor(1, RangeInt.PowerOfTwo.class);
13347  private static NISuppressor arg2_power2 =
13348      new NISuppressor(0, RangeInt.PowerOfTwo.class);
13349
13350  private static NISuppressor result_and0_arg1 =
13351      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
13352  private static NISuppressor result_and0_arg2 =
13353      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
13354  private static NISuppressor arg1_and0_arg2 =
13355      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
13356
13357  // The arguments to bitwise subset are backwards from what one
13358  // might expect.  The second argument is a subset of the first
13359  // argument
13360  private static NISuppressor arg1_bw_subset_arg2 =
13361      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
13362  private static NISuppressor arg2_bw_subset_arg1 =
13363      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
13364
13365  private static NISuppressor result_shift0_arg1 =
13366      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
13367  private static NISuppressor result_shift0_arg2 =
13368      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
13369  private static NISuppressor arg1_shift0_arg2 =
13370      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
13371
13372  private static NISuppressor arg2_divides_arg1 =
13373      new NISuppressor(1, 0, NumericInt.Divides.class);
13374  private static NISuppressor arg1_divides_arg2 =
13375      new NISuppressor(0, 1, NumericInt.Divides.class);
13376
13377  private static NISuppressor arg2_valid_shift =
13378      new NISuppressor(0, RangeInt.Bound0_63.class);
13379
13380    private static NISuppressionSet suppressions =
13381      new NISuppressionSet(
13382          new NISuppression[] {
13383            // anything mod 0 is undefined
13384            // (r == y) && (y < x) && (x != 0) && (r >= 0) ==> r = y % x
13385            new NISuppression(result_eq_arg1, arg1_lt_arg2, arg2_ne_0, result_ge_0, suppressee),
13386
13387            // (r == 0) && ((y % x) == 0)
13388            new NISuppression(result_eq_0, arg2_divides_arg1, suppressee),
13389
13390            // These are unnecessary as the divides invariant handles these
13391            // nicely.
13392            // (r == 0) && (x == 1)      ==> r = y % x
13393            // new NISuppression (result_eq_0, arg2_eq_1, suppressee),
13394
13395            // (r == 0) && (y == x)
13396            // new NISuppression (result_eq_0, arg1_eq_arg2, suppressee),
13397          });
13398
13399  // Create a suppression factory for functionBinary
13400
13401}
13402
13403  // default is that it is not this function, overriden in the subclass
13404  @Pure
13405  public boolean isLshift() {
13406    return false;
13407  }
13408
13409/**
13410 * Represents the invariant {@code x = Lshift(y, z)} over three long
13411 * scalars. 
13412 */
13413public static class LshiftLong_xyz extends FunctionBinary {
13414  // We are Serializable, so we specify a version to allow changes to
13415  // method signatures without breaking serialization.  If you add or
13416  // remove fields, you should change this number to the current date.
13417  static final long serialVersionUID = 20031030L;
13418
13419    // z must be between arg2_bound[0] and arg2_bound[1] inclusive
13420    static int[] arg2_bound = {0, 63};
13421
13422  private static @Prototype LshiftLong_xyz proto = new @Prototype LshiftLong_xyz ();
13423
13424  /** Returns the prototype invariant for LshiftLong_xyz */
13425  public static @Prototype LshiftLong_xyz get_proto() {
13426    return proto;
13427  }
13428
13429  /** instantiate an invariant on the specified slice */
13430  @Override
13431  protected LshiftLong_xyz instantiate_dyn(@Prototype LshiftLong_xyz this, PptSlice slice) {
13432    return new LshiftLong_xyz (slice);
13433  }
13434
13435  private LshiftLong_xyz (PptSlice slice) {
13436    super(slice);
13437  }
13438
13439  public @Prototype LshiftLong_xyz () {
13440    super();
13441  }
13442
13443  private static String[] method_name = new String[] {"", " << ", ""};
13444
13445  @Override
13446  public String[] get_method_name(@GuardSatisfied LshiftLong_xyz this) {
13447    return method_name;
13448  }
13449
13450  private static int function_id = -1;
13451
13452  @Override
13453  public int get_function_id() {
13454    return function_id;
13455  }
13456
13457  @Override
13458  public void set_function_id(int function_id) {
13459    assert LshiftLong_xyz.function_id == -1;
13460    LshiftLong_xyz.function_id = function_id;
13461  }
13462
13463  private static int var_order = 1;
13464
13465  @Override
13466  public int get_var_order(@GuardSatisfied LshiftLong_xyz this) {
13467    return var_order;
13468  }
13469
13470  @Pure
13471  @Override
13472  public boolean is_symmetric() {
13473
13474      return false;
13475  }
13476
13477  @Override
13478
13479  public long func(long y, long z) {
13480
13481      if ((z < arg2_bound[0]) || (z > arg2_bound[1])) {
13482        throw new ArithmeticException("arg2 (" + z + ") out of range "
13483                                       + arg2_bound[0] + ".." + arg2_bound[1]);
13484      }
13485
13486    return (y << z);
13487  }
13488
13489  @Override
13490  public InvariantStatus check_modified(long x, long y,
13491                                      long z, int count) {
13492    return check_ordered(x, y, z, count);
13493  }
13494
13495  @Override
13496  public InvariantStatus add_modified(long x, long y,
13497                                      long z, int count) {
13498    if (Debug.logDetail()) {
13499      log("result=%s, arg1=%s, arg2=%s", x, y, z);
13500    }
13501    return add_ordered(x, y, z, count);
13502  }
13503
13504  @Pure
13505  @Override
13506  public boolean isLshift() {
13507    return true;
13508  }
13509
13510  /** Returns a list of non-instantiating suppressions for this invariant. */
13511  @Pure
13512  @Override
13513  public @Nullable NISuppressionSet get_ni_suppressions() {
13514    if (NIS.dkconfig_enabled && dkconfig_enabled) {
13515      return suppressions;
13516    } else {
13517      return null;
13518    }
13519  }
13520
13521  /** definition of this invariant (the suppressee) */
13522  private static NISuppressee suppressee = new NISuppressee(LshiftLong_xyz.class, 3);
13523
13524  // suppressor definitions (used below)
13525  private static NISuppressor result_eq_arg1 =
13526      new NISuppressor(0, 1, IntEqual.class);
13527  private static NISuppressor result_eq_arg2 =
13528      new NISuppressor(0, 2, IntEqual.class);
13529  private static NISuppressor arg1_eq_arg2 =
13530      new NISuppressor(1, 2, IntEqual.class);
13531
13532  private static NISuppressor result_lt_arg1 =
13533      new NISuppressor(0, 1, IntLessThan.class);
13534  private static NISuppressor result_lt_arg2 =
13535      new NISuppressor(0, 2, IntLessThan.class);
13536  private static NISuppressor arg1_lt_arg2 =
13537      new NISuppressor(1, 2, IntLessThan.class);
13538  private static NISuppressor arg2_lt_arg1 =
13539      new NISuppressor(2, 1, IntLessThan.class);
13540
13541  private static NISuppressor result_le_arg1 =
13542      new NISuppressor(0, 1, IntLessEqual.class);
13543  private static NISuppressor result_le_arg2 =
13544      new NISuppressor(0, 2, IntLessEqual.class);
13545  private static NISuppressor arg1_le_arg2 =
13546      new NISuppressor(1, 2, IntLessEqual.class);
13547  private static NISuppressor arg2_le_arg1 =
13548      new NISuppressor(2, 1, IntLessEqual.class);
13549
13550  private static NISuppressor result_track0_arg1 =
13551      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
13552  private static NISuppressor result_track0_arg2 =
13553      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
13554  private static NISuppressor arg1_track0_arg2 =
13555      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
13556  private static NISuppressor arg1_track0_result =
13557      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
13558  private static NISuppressor arg2_track0_result =
13559      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
13560  private static NISuppressor arg2_track0_arg1 =
13561      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
13562
13563  private static NISuppressor result_eq_1 =
13564      new NISuppressor(0, RangeInt.EqualOne.class);
13565  private static NISuppressor arg1_eq_1 =
13566      new NISuppressor(1, RangeInt.EqualOne.class);
13567  private static NISuppressor arg2_eq_1 =
13568      new NISuppressor(2, RangeInt.EqualOne.class);
13569
13570  private static NISuppressor result_eq_0 =
13571      new NISuppressor(0, RangeInt.EqualZero.class);
13572  private static NISuppressor arg1_eq_0 =
13573      new NISuppressor(1, RangeInt.EqualZero.class);
13574  private static NISuppressor arg2_eq_0 =
13575      new NISuppressor(2, RangeInt.EqualZero.class);
13576
13577  private static NISuppressor result_ne_0 =
13578      new NISuppressor(0, NonZero.class);
13579  private static NISuppressor arg1_ne_0 =
13580      new NISuppressor(1, NonZero.class);
13581  private static NISuppressor arg2_ne_0 =
13582      new NISuppressor(2, NonZero.class);
13583
13584  private static NISuppressor result_ge_0 =
13585      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
13586  private static NISuppressor arg1_ge_0 =
13587      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
13588  private static NISuppressor arg2_ge_0 =
13589      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
13590
13591  private static NISuppressor result_ge_64 =
13592      new NISuppressor(0, RangeInt.GreaterEqual64.class);
13593  private static NISuppressor arg1_ge_64 =
13594      new NISuppressor(1, RangeInt.GreaterEqual64.class);
13595  private static NISuppressor arg2_ge_64 =
13596      new NISuppressor(2, RangeInt.GreaterEqual64.class);
13597
13598  private static NISuppressor result_boolean =
13599      new NISuppressor(0, RangeInt.BooleanVal.class);
13600  private static NISuppressor arg1_boolean =
13601      new NISuppressor(1, RangeInt.BooleanVal.class);
13602  private static NISuppressor arg2_boolean =
13603      new NISuppressor(2, RangeInt.BooleanVal.class);
13604
13605  private static NISuppressor result_even =
13606      new NISuppressor(0, RangeInt.Even.class);
13607  private static NISuppressor arg1_even =
13608      new NISuppressor(1, RangeInt.Even.class);
13609  private static NISuppressor arg2_even =
13610      new NISuppressor(2, RangeInt.Even.class);
13611
13612  private static NISuppressor result_power2 =
13613      new NISuppressor(0, RangeInt.PowerOfTwo.class);
13614  private static NISuppressor arg1_power2 =
13615      new NISuppressor(1, RangeInt.PowerOfTwo.class);
13616  private static NISuppressor arg2_power2 =
13617      new NISuppressor(2, RangeInt.PowerOfTwo.class);
13618
13619  private static NISuppressor result_and0_arg1 =
13620      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
13621  private static NISuppressor result_and0_arg2 =
13622      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
13623  private static NISuppressor arg1_and0_arg2 =
13624      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
13625
13626  // The arguments to bitwise subset are backwards from what one
13627  // might expect.  The second argument is a subset of the first
13628  // argument
13629  private static NISuppressor arg1_bw_subset_arg2 =
13630      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
13631  private static NISuppressor arg2_bw_subset_arg1 =
13632      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
13633
13634  private static NISuppressor result_shift0_arg1 =
13635      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
13636  private static NISuppressor result_shift0_arg2 =
13637      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
13638  private static NISuppressor arg1_shift0_arg2 =
13639      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
13640
13641  private static NISuppressor arg2_divides_arg1 =
13642      new NISuppressor(1, 2, NumericInt.Divides.class);
13643  private static NISuppressor arg1_divides_arg2 =
13644      new NISuppressor(2, 1, NumericInt.Divides.class);
13645
13646  private static NISuppressor arg2_valid_shift =
13647      new NISuppressor(2, RangeInt.Bound0_63.class);
13648
13649    private static NISuppressionSet suppressions =
13650        new NISuppressionSet(
13651          new NISuppression[] {
13652
13653            // (r == y) && (z == 0) ==> r = y << z
13654            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
13655
13656            // (r == 0) && (y == 0) && (0 <= z <= 63)   ==> r = y << z
13657            new NISuppression(result_eq_0, arg1_eq_0, arg2_valid_shift,
13658                               suppressee),
13659
13660          });
13661
13662  // Create a suppression factory for functionBinary
13663
13664}
13665
13666/**
13667 * Represents the invariant {@code y = Lshift(x, z)} over three long
13668 * scalars. 
13669 */
13670public static class LshiftLong_yxz extends FunctionBinary {
13671  // We are Serializable, so we specify a version to allow changes to
13672  // method signatures without breaking serialization.  If you add or
13673  // remove fields, you should change this number to the current date.
13674  static final long serialVersionUID = 20031030L;
13675
13676    // z must be between arg2_bound[0] and arg2_bound[1] inclusive
13677    static int[] arg2_bound = {0, 63};
13678
13679  private static @Prototype LshiftLong_yxz proto = new @Prototype LshiftLong_yxz ();
13680
13681  /** Returns the prototype invariant for LshiftLong_yxz */
13682  public static @Prototype LshiftLong_yxz get_proto() {
13683    return proto;
13684  }
13685
13686  /** instantiate an invariant on the specified slice */
13687  @Override
13688  protected LshiftLong_yxz instantiate_dyn(@Prototype LshiftLong_yxz this, PptSlice slice) {
13689    return new LshiftLong_yxz (slice);
13690  }
13691
13692  private LshiftLong_yxz (PptSlice slice) {
13693    super(slice);
13694  }
13695
13696  public @Prototype LshiftLong_yxz () {
13697    super();
13698  }
13699
13700  private static String[] method_name = new String[] {"", " << ", ""};
13701
13702  @Override
13703  public String[] get_method_name(@GuardSatisfied LshiftLong_yxz this) {
13704    return method_name;
13705  }
13706
13707  private static int function_id = -1;
13708
13709  @Override
13710  public int get_function_id() {
13711    return function_id;
13712  }
13713
13714  @Override
13715  public void set_function_id(int function_id) {
13716    assert LshiftLong_yxz.function_id == -1;
13717    LshiftLong_yxz.function_id = function_id;
13718  }
13719
13720  private static int var_order = 2;
13721
13722  @Override
13723  public int get_var_order(@GuardSatisfied LshiftLong_yxz this) {
13724    return var_order;
13725  }
13726
13727  @Pure
13728  @Override
13729  public boolean is_symmetric() {
13730
13731      return false;
13732  }
13733
13734  @Override
13735
13736  public long func(long x, long z) {
13737
13738      if ((z < arg2_bound[0]) || (z > arg2_bound[1])) {
13739        throw new ArithmeticException("arg2 (" + z + ") out of range "
13740                                       + arg2_bound[0] + ".." + arg2_bound[1]);
13741      }
13742
13743    return (x << z);
13744  }
13745
13746  @Override
13747  public InvariantStatus check_modified(long x, long y,
13748                                      long z, int count) {
13749    return check_ordered(y, x, z, count);
13750  }
13751
13752  @Override
13753  public InvariantStatus add_modified(long x, long y,
13754                                      long z, int count) {
13755    if (Debug.logDetail()) {
13756      log("result=%s, arg1=%s, arg2=%s", y, x, z);
13757    }
13758    return add_ordered(y, x, z, count);
13759  }
13760
13761  @Pure
13762  @Override
13763  public boolean isLshift() {
13764    return true;
13765  }
13766
13767  /** Returns a list of non-instantiating suppressions for this invariant. */
13768  @Pure
13769  @Override
13770  public @Nullable NISuppressionSet get_ni_suppressions() {
13771    if (NIS.dkconfig_enabled && dkconfig_enabled) {
13772      return suppressions;
13773    } else {
13774      return null;
13775    }
13776  }
13777
13778  /** definition of this invariant (the suppressee) */
13779  private static NISuppressee suppressee = new NISuppressee(LshiftLong_yxz.class, 3);
13780
13781  // suppressor definitions (used below)
13782  private static NISuppressor result_eq_arg1 =
13783      new NISuppressor(1, 0, IntEqual.class);
13784  private static NISuppressor result_eq_arg2 =
13785      new NISuppressor(1, 2, IntEqual.class);
13786  private static NISuppressor arg1_eq_arg2 =
13787      new NISuppressor(0, 2, IntEqual.class);
13788
13789  private static NISuppressor result_lt_arg1 =
13790      new NISuppressor(1, 0, IntLessThan.class);
13791  private static NISuppressor result_lt_arg2 =
13792      new NISuppressor(1, 2, IntLessThan.class);
13793  private static NISuppressor arg1_lt_arg2 =
13794      new NISuppressor(0, 2, IntLessThan.class);
13795  private static NISuppressor arg2_lt_arg1 =
13796      new NISuppressor(2, 0, IntLessThan.class);
13797
13798  private static NISuppressor result_le_arg1 =
13799      new NISuppressor(1, 0, IntLessEqual.class);
13800  private static NISuppressor result_le_arg2 =
13801      new NISuppressor(1, 2, IntLessEqual.class);
13802  private static NISuppressor arg1_le_arg2 =
13803      new NISuppressor(0, 2, IntLessEqual.class);
13804  private static NISuppressor arg2_le_arg1 =
13805      new NISuppressor(2, 0, IntLessEqual.class);
13806
13807  private static NISuppressor result_track0_arg1 =
13808      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
13809  private static NISuppressor result_track0_arg2 =
13810      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
13811  private static NISuppressor arg1_track0_arg2 =
13812      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
13813  private static NISuppressor arg1_track0_result =
13814      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
13815  private static NISuppressor arg2_track0_result =
13816      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
13817  private static NISuppressor arg2_track0_arg1 =
13818      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
13819
13820  private static NISuppressor result_eq_1 =
13821      new NISuppressor(1, RangeInt.EqualOne.class);
13822  private static NISuppressor arg1_eq_1 =
13823      new NISuppressor(0, RangeInt.EqualOne.class);
13824  private static NISuppressor arg2_eq_1 =
13825      new NISuppressor(2, RangeInt.EqualOne.class);
13826
13827  private static NISuppressor result_eq_0 =
13828      new NISuppressor(1, RangeInt.EqualZero.class);
13829  private static NISuppressor arg1_eq_0 =
13830      new NISuppressor(0, RangeInt.EqualZero.class);
13831  private static NISuppressor arg2_eq_0 =
13832      new NISuppressor(2, RangeInt.EqualZero.class);
13833
13834  private static NISuppressor result_ne_0 =
13835      new NISuppressor(1, NonZero.class);
13836  private static NISuppressor arg1_ne_0 =
13837      new NISuppressor(0, NonZero.class);
13838  private static NISuppressor arg2_ne_0 =
13839      new NISuppressor(2, NonZero.class);
13840
13841  private static NISuppressor result_ge_0 =
13842      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
13843  private static NISuppressor arg1_ge_0 =
13844      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
13845  private static NISuppressor arg2_ge_0 =
13846      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
13847
13848  private static NISuppressor result_ge_64 =
13849      new NISuppressor(1, RangeInt.GreaterEqual64.class);
13850  private static NISuppressor arg1_ge_64 =
13851      new NISuppressor(0, RangeInt.GreaterEqual64.class);
13852  private static NISuppressor arg2_ge_64 =
13853      new NISuppressor(2, RangeInt.GreaterEqual64.class);
13854
13855  private static NISuppressor result_boolean =
13856      new NISuppressor(1, RangeInt.BooleanVal.class);
13857  private static NISuppressor arg1_boolean =
13858      new NISuppressor(0, RangeInt.BooleanVal.class);
13859  private static NISuppressor arg2_boolean =
13860      new NISuppressor(2, RangeInt.BooleanVal.class);
13861
13862  private static NISuppressor result_even =
13863      new NISuppressor(1, RangeInt.Even.class);
13864  private static NISuppressor arg1_even =
13865      new NISuppressor(0, RangeInt.Even.class);
13866  private static NISuppressor arg2_even =
13867      new NISuppressor(2, RangeInt.Even.class);
13868
13869  private static NISuppressor result_power2 =
13870      new NISuppressor(1, RangeInt.PowerOfTwo.class);
13871  private static NISuppressor arg1_power2 =
13872      new NISuppressor(0, RangeInt.PowerOfTwo.class);
13873  private static NISuppressor arg2_power2 =
13874      new NISuppressor(2, RangeInt.PowerOfTwo.class);
13875
13876  private static NISuppressor result_and0_arg1 =
13877      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
13878  private static NISuppressor result_and0_arg2 =
13879      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
13880  private static NISuppressor arg1_and0_arg2 =
13881      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
13882
13883  // The arguments to bitwise subset are backwards from what one
13884  // might expect.  The second argument is a subset of the first
13885  // argument
13886  private static NISuppressor arg1_bw_subset_arg2 =
13887      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
13888  private static NISuppressor arg2_bw_subset_arg1 =
13889      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
13890
13891  private static NISuppressor result_shift0_arg1 =
13892      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
13893  private static NISuppressor result_shift0_arg2 =
13894      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
13895  private static NISuppressor arg1_shift0_arg2 =
13896      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
13897
13898  private static NISuppressor arg2_divides_arg1 =
13899      new NISuppressor(0, 2, NumericInt.Divides.class);
13900  private static NISuppressor arg1_divides_arg2 =
13901      new NISuppressor(2, 0, NumericInt.Divides.class);
13902
13903  private static NISuppressor arg2_valid_shift =
13904      new NISuppressor(2, RangeInt.Bound0_63.class);
13905
13906    private static NISuppressionSet suppressions =
13907        new NISuppressionSet(
13908          new NISuppression[] {
13909
13910            // (r == x) && (z == 0) ==> r = x << z
13911            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
13912
13913            // (r == 0) && (x == 0) && (0 <= z <= 63)   ==> r = x << z
13914            new NISuppression(result_eq_0, arg1_eq_0, arg2_valid_shift,
13915                               suppressee),
13916
13917          });
13918
13919  // Create a suppression factory for functionBinary
13920
13921}
13922
13923/**
13924 * Represents the invariant {@code z = Lshift(x, y)} over three long
13925 * scalars. 
13926 */
13927public static class LshiftLong_zxy extends FunctionBinary {
13928  // We are Serializable, so we specify a version to allow changes to
13929  // method signatures without breaking serialization.  If you add or
13930  // remove fields, you should change this number to the current date.
13931  static final long serialVersionUID = 20031030L;
13932
13933    // y must be between arg2_bound[0] and arg2_bound[1] inclusive
13934    static int[] arg2_bound = {0, 63};
13935
13936  private static @Prototype LshiftLong_zxy proto = new @Prototype LshiftLong_zxy ();
13937
13938  /** Returns the prototype invariant for LshiftLong_zxy */
13939  public static @Prototype LshiftLong_zxy get_proto() {
13940    return proto;
13941  }
13942
13943  /** instantiate an invariant on the specified slice */
13944  @Override
13945  protected LshiftLong_zxy instantiate_dyn(@Prototype LshiftLong_zxy this, PptSlice slice) {
13946    return new LshiftLong_zxy (slice);
13947  }
13948
13949  private LshiftLong_zxy (PptSlice slice) {
13950    super(slice);
13951  }
13952
13953  public @Prototype LshiftLong_zxy () {
13954    super();
13955  }
13956
13957  private static String[] method_name = new String[] {"", " << ", ""};
13958
13959  @Override
13960  public String[] get_method_name(@GuardSatisfied LshiftLong_zxy this) {
13961    return method_name;
13962  }
13963
13964  private static int function_id = -1;
13965
13966  @Override
13967  public int get_function_id() {
13968    return function_id;
13969  }
13970
13971  @Override
13972  public void set_function_id(int function_id) {
13973    assert LshiftLong_zxy.function_id == -1;
13974    LshiftLong_zxy.function_id = function_id;
13975  }
13976
13977  private static int var_order = 3;
13978
13979  @Override
13980  public int get_var_order(@GuardSatisfied LshiftLong_zxy this) {
13981    return var_order;
13982  }
13983
13984  @Pure
13985  @Override
13986  public boolean is_symmetric() {
13987
13988      return false;
13989  }
13990
13991  @Override
13992
13993  public long func(long x, long y) {
13994
13995      if ((y < arg2_bound[0]) || (y > arg2_bound[1])) {
13996        throw new ArithmeticException("arg2 (" + y + ") out of range "
13997                                       + arg2_bound[0] + ".." + arg2_bound[1]);
13998      }
13999
14000    return (x << y);
14001  }
14002
14003  @Override
14004  public InvariantStatus check_modified(long x, long y,
14005                                      long z, int count) {
14006    return check_ordered(z, x, y, count);
14007  }
14008
14009  @Override
14010  public InvariantStatus add_modified(long x, long y,
14011                                      long z, int count) {
14012    if (Debug.logDetail()) {
14013      log("result=%s, arg1=%s, arg2=%s", z, x, y);
14014    }
14015    return add_ordered(z, x, y, count);
14016  }
14017
14018  @Pure
14019  @Override
14020  public boolean isLshift() {
14021    return true;
14022  }
14023
14024  /** Returns a list of non-instantiating suppressions for this invariant. */
14025  @Pure
14026  @Override
14027  public @Nullable NISuppressionSet get_ni_suppressions() {
14028    if (NIS.dkconfig_enabled && dkconfig_enabled) {
14029      return suppressions;
14030    } else {
14031      return null;
14032    }
14033  }
14034
14035  /** definition of this invariant (the suppressee) */
14036  private static NISuppressee suppressee = new NISuppressee(LshiftLong_zxy.class, 3);
14037
14038  // suppressor definitions (used below)
14039  private static NISuppressor result_eq_arg1 =
14040      new NISuppressor(2, 0, IntEqual.class);
14041  private static NISuppressor result_eq_arg2 =
14042      new NISuppressor(2, 1, IntEqual.class);
14043  private static NISuppressor arg1_eq_arg2 =
14044      new NISuppressor(0, 1, IntEqual.class);
14045
14046  private static NISuppressor result_lt_arg1 =
14047      new NISuppressor(2, 0, IntLessThan.class);
14048  private static NISuppressor result_lt_arg2 =
14049      new NISuppressor(2, 1, IntLessThan.class);
14050  private static NISuppressor arg1_lt_arg2 =
14051      new NISuppressor(0, 1, IntLessThan.class);
14052  private static NISuppressor arg2_lt_arg1 =
14053      new NISuppressor(1, 0, IntLessThan.class);
14054
14055  private static NISuppressor result_le_arg1 =
14056      new NISuppressor(2, 0, IntLessEqual.class);
14057  private static NISuppressor result_le_arg2 =
14058      new NISuppressor(2, 1, IntLessEqual.class);
14059  private static NISuppressor arg1_le_arg2 =
14060      new NISuppressor(0, 1, IntLessEqual.class);
14061  private static NISuppressor arg2_le_arg1 =
14062      new NISuppressor(1, 0, IntLessEqual.class);
14063
14064  private static NISuppressor result_track0_arg1 =
14065      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
14066  private static NISuppressor result_track0_arg2 =
14067      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
14068  private static NISuppressor arg1_track0_arg2 =
14069      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
14070  private static NISuppressor arg1_track0_result =
14071      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
14072  private static NISuppressor arg2_track0_result =
14073      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
14074  private static NISuppressor arg2_track0_arg1 =
14075      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
14076
14077  private static NISuppressor result_eq_1 =
14078      new NISuppressor(2, RangeInt.EqualOne.class);
14079  private static NISuppressor arg1_eq_1 =
14080      new NISuppressor(0, RangeInt.EqualOne.class);
14081  private static NISuppressor arg2_eq_1 =
14082      new NISuppressor(1, RangeInt.EqualOne.class);
14083
14084  private static NISuppressor result_eq_0 =
14085      new NISuppressor(2, RangeInt.EqualZero.class);
14086  private static NISuppressor arg1_eq_0 =
14087      new NISuppressor(0, RangeInt.EqualZero.class);
14088  private static NISuppressor arg2_eq_0 =
14089      new NISuppressor(1, RangeInt.EqualZero.class);
14090
14091  private static NISuppressor result_ne_0 =
14092      new NISuppressor(2, NonZero.class);
14093  private static NISuppressor arg1_ne_0 =
14094      new NISuppressor(0, NonZero.class);
14095  private static NISuppressor arg2_ne_0 =
14096      new NISuppressor(1, NonZero.class);
14097
14098  private static NISuppressor result_ge_0 =
14099      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
14100  private static NISuppressor arg1_ge_0 =
14101      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
14102  private static NISuppressor arg2_ge_0 =
14103      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
14104
14105  private static NISuppressor result_ge_64 =
14106      new NISuppressor(2, RangeInt.GreaterEqual64.class);
14107  private static NISuppressor arg1_ge_64 =
14108      new NISuppressor(0, RangeInt.GreaterEqual64.class);
14109  private static NISuppressor arg2_ge_64 =
14110      new NISuppressor(1, RangeInt.GreaterEqual64.class);
14111
14112  private static NISuppressor result_boolean =
14113      new NISuppressor(2, RangeInt.BooleanVal.class);
14114  private static NISuppressor arg1_boolean =
14115      new NISuppressor(0, RangeInt.BooleanVal.class);
14116  private static NISuppressor arg2_boolean =
14117      new NISuppressor(1, RangeInt.BooleanVal.class);
14118
14119  private static NISuppressor result_even =
14120      new NISuppressor(2, RangeInt.Even.class);
14121  private static NISuppressor arg1_even =
14122      new NISuppressor(0, RangeInt.Even.class);
14123  private static NISuppressor arg2_even =
14124      new NISuppressor(1, RangeInt.Even.class);
14125
14126  private static NISuppressor result_power2 =
14127      new NISuppressor(2, RangeInt.PowerOfTwo.class);
14128  private static NISuppressor arg1_power2 =
14129      new NISuppressor(0, RangeInt.PowerOfTwo.class);
14130  private static NISuppressor arg2_power2 =
14131      new NISuppressor(1, RangeInt.PowerOfTwo.class);
14132
14133  private static NISuppressor result_and0_arg1 =
14134      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
14135  private static NISuppressor result_and0_arg2 =
14136      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
14137  private static NISuppressor arg1_and0_arg2 =
14138      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
14139
14140  // The arguments to bitwise subset are backwards from what one
14141  // might expect.  The second argument is a subset of the first
14142  // argument
14143  private static NISuppressor arg1_bw_subset_arg2 =
14144      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
14145  private static NISuppressor arg2_bw_subset_arg1 =
14146      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
14147
14148  private static NISuppressor result_shift0_arg1 =
14149      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
14150  private static NISuppressor result_shift0_arg2 =
14151      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
14152  private static NISuppressor arg1_shift0_arg2 =
14153      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
14154
14155  private static NISuppressor arg2_divides_arg1 =
14156      new NISuppressor(0, 1, NumericInt.Divides.class);
14157  private static NISuppressor arg1_divides_arg2 =
14158      new NISuppressor(1, 0, NumericInt.Divides.class);
14159
14160  private static NISuppressor arg2_valid_shift =
14161      new NISuppressor(1, RangeInt.Bound0_63.class);
14162
14163    private static NISuppressionSet suppressions =
14164        new NISuppressionSet(
14165          new NISuppression[] {
14166
14167            // (r == x) && (y == 0) ==> r = x << y
14168            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
14169
14170            // (r == 0) && (x == 0) && (0 <= y <= 63)   ==> r = x << y
14171            new NISuppression(result_eq_0, arg1_eq_0, arg2_valid_shift,
14172                               suppressee),
14173
14174          });
14175
14176  // Create a suppression factory for functionBinary
14177
14178}
14179
14180/**
14181 * Represents the invariant {@code x = Lshift(z, y)} over three long
14182 * scalars. 
14183 */
14184public static class LshiftLong_xzy extends FunctionBinary {
14185  // We are Serializable, so we specify a version to allow changes to
14186  // method signatures without breaking serialization.  If you add or
14187  // remove fields, you should change this number to the current date.
14188  static final long serialVersionUID = 20031030L;
14189
14190    // y must be between arg2_bound[0] and arg2_bound[1] inclusive
14191    static int[] arg2_bound = {0, 63};
14192
14193  private static @Prototype LshiftLong_xzy proto = new @Prototype LshiftLong_xzy ();
14194
14195  /** Returns the prototype invariant for LshiftLong_xzy */
14196  public static @Prototype LshiftLong_xzy get_proto() {
14197    return proto;
14198  }
14199
14200  /** instantiate an invariant on the specified slice */
14201  @Override
14202  protected LshiftLong_xzy instantiate_dyn(@Prototype LshiftLong_xzy this, PptSlice slice) {
14203    return new LshiftLong_xzy (slice);
14204  }
14205
14206  private LshiftLong_xzy (PptSlice slice) {
14207    super(slice);
14208  }
14209
14210  public @Prototype LshiftLong_xzy () {
14211    super();
14212  }
14213
14214  private static String[] method_name = new String[] {"", " << ", ""};
14215
14216  @Override
14217  public String[] get_method_name(@GuardSatisfied LshiftLong_xzy this) {
14218    return method_name;
14219  }
14220
14221  private static int function_id = -1;
14222
14223  @Override
14224  public int get_function_id() {
14225    return function_id;
14226  }
14227
14228  @Override
14229  public void set_function_id(int function_id) {
14230    assert LshiftLong_xzy.function_id == -1;
14231    LshiftLong_xzy.function_id = function_id;
14232  }
14233
14234  private static int var_order = 4;
14235
14236  @Override
14237  public int get_var_order(@GuardSatisfied LshiftLong_xzy this) {
14238    return var_order;
14239  }
14240
14241  @Pure
14242  @Override
14243  public boolean is_symmetric() {
14244
14245      return false;
14246  }
14247
14248  @Override
14249
14250  public long func(long z, long y) {
14251
14252      if ((y < arg2_bound[0]) || (y > arg2_bound[1])) {
14253        throw new ArithmeticException("arg2 (" + y + ") out of range "
14254                                       + arg2_bound[0] + ".." + arg2_bound[1]);
14255      }
14256
14257    return (z << y);
14258  }
14259
14260  @Override
14261  public InvariantStatus check_modified(long x, long y,
14262                                      long z, int count) {
14263    return check_ordered(x, z, y, count);
14264  }
14265
14266  @Override
14267  public InvariantStatus add_modified(long x, long y,
14268                                      long z, int count) {
14269    if (Debug.logDetail()) {
14270      log("result=%s, arg1=%s, arg2=%s", x, z, y);
14271    }
14272    return add_ordered(x, z, y, count);
14273  }
14274
14275  @Pure
14276  @Override
14277  public boolean isLshift() {
14278    return true;
14279  }
14280
14281  /** Returns a list of non-instantiating suppressions for this invariant. */
14282  @Pure
14283  @Override
14284  public @Nullable NISuppressionSet get_ni_suppressions() {
14285    if (NIS.dkconfig_enabled && dkconfig_enabled) {
14286      return suppressions;
14287    } else {
14288      return null;
14289    }
14290  }
14291
14292  /** definition of this invariant (the suppressee) */
14293  private static NISuppressee suppressee = new NISuppressee(LshiftLong_xzy.class, 3);
14294
14295  // suppressor definitions (used below)
14296  private static NISuppressor result_eq_arg1 =
14297      new NISuppressor(0, 2, IntEqual.class);
14298  private static NISuppressor result_eq_arg2 =
14299      new NISuppressor(0, 1, IntEqual.class);
14300  private static NISuppressor arg1_eq_arg2 =
14301      new NISuppressor(2, 1, IntEqual.class);
14302
14303  private static NISuppressor result_lt_arg1 =
14304      new NISuppressor(0, 2, IntLessThan.class);
14305  private static NISuppressor result_lt_arg2 =
14306      new NISuppressor(0, 1, IntLessThan.class);
14307  private static NISuppressor arg1_lt_arg2 =
14308      new NISuppressor(2, 1, IntLessThan.class);
14309  private static NISuppressor arg2_lt_arg1 =
14310      new NISuppressor(1, 2, IntLessThan.class);
14311
14312  private static NISuppressor result_le_arg1 =
14313      new NISuppressor(0, 2, IntLessEqual.class);
14314  private static NISuppressor result_le_arg2 =
14315      new NISuppressor(0, 1, IntLessEqual.class);
14316  private static NISuppressor arg1_le_arg2 =
14317      new NISuppressor(2, 1, IntLessEqual.class);
14318  private static NISuppressor arg2_le_arg1 =
14319      new NISuppressor(1, 2, IntLessEqual.class);
14320
14321  private static NISuppressor result_track0_arg1 =
14322      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
14323  private static NISuppressor result_track0_arg2 =
14324      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
14325  private static NISuppressor arg1_track0_arg2 =
14326      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
14327  private static NISuppressor arg1_track0_result =
14328      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
14329  private static NISuppressor arg2_track0_result =
14330      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
14331  private static NISuppressor arg2_track0_arg1 =
14332      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
14333
14334  private static NISuppressor result_eq_1 =
14335      new NISuppressor(0, RangeInt.EqualOne.class);
14336  private static NISuppressor arg1_eq_1 =
14337      new NISuppressor(2, RangeInt.EqualOne.class);
14338  private static NISuppressor arg2_eq_1 =
14339      new NISuppressor(1, RangeInt.EqualOne.class);
14340
14341  private static NISuppressor result_eq_0 =
14342      new NISuppressor(0, RangeInt.EqualZero.class);
14343  private static NISuppressor arg1_eq_0 =
14344      new NISuppressor(2, RangeInt.EqualZero.class);
14345  private static NISuppressor arg2_eq_0 =
14346      new NISuppressor(1, RangeInt.EqualZero.class);
14347
14348  private static NISuppressor result_ne_0 =
14349      new NISuppressor(0, NonZero.class);
14350  private static NISuppressor arg1_ne_0 =
14351      new NISuppressor(2, NonZero.class);
14352  private static NISuppressor arg2_ne_0 =
14353      new NISuppressor(1, NonZero.class);
14354
14355  private static NISuppressor result_ge_0 =
14356      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
14357  private static NISuppressor arg1_ge_0 =
14358      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
14359  private static NISuppressor arg2_ge_0 =
14360      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
14361
14362  private static NISuppressor result_ge_64 =
14363      new NISuppressor(0, RangeInt.GreaterEqual64.class);
14364  private static NISuppressor arg1_ge_64 =
14365      new NISuppressor(2, RangeInt.GreaterEqual64.class);
14366  private static NISuppressor arg2_ge_64 =
14367      new NISuppressor(1, RangeInt.GreaterEqual64.class);
14368
14369  private static NISuppressor result_boolean =
14370      new NISuppressor(0, RangeInt.BooleanVal.class);
14371  private static NISuppressor arg1_boolean =
14372      new NISuppressor(2, RangeInt.BooleanVal.class);
14373  private static NISuppressor arg2_boolean =
14374      new NISuppressor(1, RangeInt.BooleanVal.class);
14375
14376  private static NISuppressor result_even =
14377      new NISuppressor(0, RangeInt.Even.class);
14378  private static NISuppressor arg1_even =
14379      new NISuppressor(2, RangeInt.Even.class);
14380  private static NISuppressor arg2_even =
14381      new NISuppressor(1, RangeInt.Even.class);
14382
14383  private static NISuppressor result_power2 =
14384      new NISuppressor(0, RangeInt.PowerOfTwo.class);
14385  private static NISuppressor arg1_power2 =
14386      new NISuppressor(2, RangeInt.PowerOfTwo.class);
14387  private static NISuppressor arg2_power2 =
14388      new NISuppressor(1, RangeInt.PowerOfTwo.class);
14389
14390  private static NISuppressor result_and0_arg1 =
14391      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
14392  private static NISuppressor result_and0_arg2 =
14393      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
14394  private static NISuppressor arg1_and0_arg2 =
14395      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
14396
14397  // The arguments to bitwise subset are backwards from what one
14398  // might expect.  The second argument is a subset of the first
14399  // argument
14400  private static NISuppressor arg1_bw_subset_arg2 =
14401      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
14402  private static NISuppressor arg2_bw_subset_arg1 =
14403      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
14404
14405  private static NISuppressor result_shift0_arg1 =
14406      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
14407  private static NISuppressor result_shift0_arg2 =
14408      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
14409  private static NISuppressor arg1_shift0_arg2 =
14410      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
14411
14412  private static NISuppressor arg2_divides_arg1 =
14413      new NISuppressor(2, 1, NumericInt.Divides.class);
14414  private static NISuppressor arg1_divides_arg2 =
14415      new NISuppressor(1, 2, NumericInt.Divides.class);
14416
14417  private static NISuppressor arg2_valid_shift =
14418      new NISuppressor(1, RangeInt.Bound0_63.class);
14419
14420    private static NISuppressionSet suppressions =
14421        new NISuppressionSet(
14422          new NISuppression[] {
14423
14424            // (r == z) && (y == 0) ==> r = z << y
14425            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
14426
14427            // (r == 0) && (z == 0) && (0 <= y <= 63)   ==> r = z << y
14428            new NISuppression(result_eq_0, arg1_eq_0, arg2_valid_shift,
14429                               suppressee),
14430
14431          });
14432
14433  // Create a suppression factory for functionBinary
14434
14435}
14436
14437/**
14438 * Represents the invariant {@code y = Lshift(z, x)} over three long
14439 * scalars. 
14440 */
14441public static class LshiftLong_yzx extends FunctionBinary {
14442  // We are Serializable, so we specify a version to allow changes to
14443  // method signatures without breaking serialization.  If you add or
14444  // remove fields, you should change this number to the current date.
14445  static final long serialVersionUID = 20031030L;
14446
14447    // x must be between arg2_bound[0] and arg2_bound[1] inclusive
14448    static int[] arg2_bound = {0, 63};
14449
14450  private static @Prototype LshiftLong_yzx proto = new @Prototype LshiftLong_yzx ();
14451
14452  /** Returns the prototype invariant for LshiftLong_yzx */
14453  public static @Prototype LshiftLong_yzx get_proto() {
14454    return proto;
14455  }
14456
14457  /** instantiate an invariant on the specified slice */
14458  @Override
14459  protected LshiftLong_yzx instantiate_dyn(@Prototype LshiftLong_yzx this, PptSlice slice) {
14460    return new LshiftLong_yzx (slice);
14461  }
14462
14463  private LshiftLong_yzx (PptSlice slice) {
14464    super(slice);
14465  }
14466
14467  public @Prototype LshiftLong_yzx () {
14468    super();
14469  }
14470
14471  private static String[] method_name = new String[] {"", " << ", ""};
14472
14473  @Override
14474  public String[] get_method_name(@GuardSatisfied LshiftLong_yzx this) {
14475    return method_name;
14476  }
14477
14478  private static int function_id = -1;
14479
14480  @Override
14481  public int get_function_id() {
14482    return function_id;
14483  }
14484
14485  @Override
14486  public void set_function_id(int function_id) {
14487    assert LshiftLong_yzx.function_id == -1;
14488    LshiftLong_yzx.function_id = function_id;
14489  }
14490
14491  private static int var_order = 5;
14492
14493  @Override
14494  public int get_var_order(@GuardSatisfied LshiftLong_yzx this) {
14495    return var_order;
14496  }
14497
14498  @Pure
14499  @Override
14500  public boolean is_symmetric() {
14501
14502      return false;
14503  }
14504
14505  @Override
14506
14507  public long func(long z, long x) {
14508
14509      if ((x < arg2_bound[0]) || (x > arg2_bound[1])) {
14510        throw new ArithmeticException("arg2 (" + x + ") out of range "
14511                                       + arg2_bound[0] + ".." + arg2_bound[1]);
14512      }
14513
14514    return (z << x);
14515  }
14516
14517  @Override
14518  public InvariantStatus check_modified(long x, long y,
14519                                      long z, int count) {
14520    return check_ordered(y, z, x, count);
14521  }
14522
14523  @Override
14524  public InvariantStatus add_modified(long x, long y,
14525                                      long z, int count) {
14526    if (Debug.logDetail()) {
14527      log("result=%s, arg1=%s, arg2=%s", y, z, x);
14528    }
14529    return add_ordered(y, z, x, count);
14530  }
14531
14532  @Pure
14533  @Override
14534  public boolean isLshift() {
14535    return true;
14536  }
14537
14538  /** Returns a list of non-instantiating suppressions for this invariant. */
14539  @Pure
14540  @Override
14541  public @Nullable NISuppressionSet get_ni_suppressions() {
14542    if (NIS.dkconfig_enabled && dkconfig_enabled) {
14543      return suppressions;
14544    } else {
14545      return null;
14546    }
14547  }
14548
14549  /** definition of this invariant (the suppressee) */
14550  private static NISuppressee suppressee = new NISuppressee(LshiftLong_yzx.class, 3);
14551
14552  // suppressor definitions (used below)
14553  private static NISuppressor result_eq_arg1 =
14554      new NISuppressor(1, 2, IntEqual.class);
14555  private static NISuppressor result_eq_arg2 =
14556      new NISuppressor(1, 0, IntEqual.class);
14557  private static NISuppressor arg1_eq_arg2 =
14558      new NISuppressor(2, 0, IntEqual.class);
14559
14560  private static NISuppressor result_lt_arg1 =
14561      new NISuppressor(1, 2, IntLessThan.class);
14562  private static NISuppressor result_lt_arg2 =
14563      new NISuppressor(1, 0, IntLessThan.class);
14564  private static NISuppressor arg1_lt_arg2 =
14565      new NISuppressor(2, 0, IntLessThan.class);
14566  private static NISuppressor arg2_lt_arg1 =
14567      new NISuppressor(0, 2, IntLessThan.class);
14568
14569  private static NISuppressor result_le_arg1 =
14570      new NISuppressor(1, 2, IntLessEqual.class);
14571  private static NISuppressor result_le_arg2 =
14572      new NISuppressor(1, 0, IntLessEqual.class);
14573  private static NISuppressor arg1_le_arg2 =
14574      new NISuppressor(2, 0, IntLessEqual.class);
14575  private static NISuppressor arg2_le_arg1 =
14576      new NISuppressor(0, 2, IntLessEqual.class);
14577
14578  private static NISuppressor result_track0_arg1 =
14579      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
14580  private static NISuppressor result_track0_arg2 =
14581      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
14582  private static NISuppressor arg1_track0_arg2 =
14583      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
14584  private static NISuppressor arg1_track0_result =
14585      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
14586  private static NISuppressor arg2_track0_result =
14587      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
14588  private static NISuppressor arg2_track0_arg1 =
14589      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
14590
14591  private static NISuppressor result_eq_1 =
14592      new NISuppressor(1, RangeInt.EqualOne.class);
14593  private static NISuppressor arg1_eq_1 =
14594      new NISuppressor(2, RangeInt.EqualOne.class);
14595  private static NISuppressor arg2_eq_1 =
14596      new NISuppressor(0, RangeInt.EqualOne.class);
14597
14598  private static NISuppressor result_eq_0 =
14599      new NISuppressor(1, RangeInt.EqualZero.class);
14600  private static NISuppressor arg1_eq_0 =
14601      new NISuppressor(2, RangeInt.EqualZero.class);
14602  private static NISuppressor arg2_eq_0 =
14603      new NISuppressor(0, RangeInt.EqualZero.class);
14604
14605  private static NISuppressor result_ne_0 =
14606      new NISuppressor(1, NonZero.class);
14607  private static NISuppressor arg1_ne_0 =
14608      new NISuppressor(2, NonZero.class);
14609  private static NISuppressor arg2_ne_0 =
14610      new NISuppressor(0, NonZero.class);
14611
14612  private static NISuppressor result_ge_0 =
14613      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
14614  private static NISuppressor arg1_ge_0 =
14615      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
14616  private static NISuppressor arg2_ge_0 =
14617      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
14618
14619  private static NISuppressor result_ge_64 =
14620      new NISuppressor(1, RangeInt.GreaterEqual64.class);
14621  private static NISuppressor arg1_ge_64 =
14622      new NISuppressor(2, RangeInt.GreaterEqual64.class);
14623  private static NISuppressor arg2_ge_64 =
14624      new NISuppressor(0, RangeInt.GreaterEqual64.class);
14625
14626  private static NISuppressor result_boolean =
14627      new NISuppressor(1, RangeInt.BooleanVal.class);
14628  private static NISuppressor arg1_boolean =
14629      new NISuppressor(2, RangeInt.BooleanVal.class);
14630  private static NISuppressor arg2_boolean =
14631      new NISuppressor(0, RangeInt.BooleanVal.class);
14632
14633  private static NISuppressor result_even =
14634      new NISuppressor(1, RangeInt.Even.class);
14635  private static NISuppressor arg1_even =
14636      new NISuppressor(2, RangeInt.Even.class);
14637  private static NISuppressor arg2_even =
14638      new NISuppressor(0, RangeInt.Even.class);
14639
14640  private static NISuppressor result_power2 =
14641      new NISuppressor(1, RangeInt.PowerOfTwo.class);
14642  private static NISuppressor arg1_power2 =
14643      new NISuppressor(2, RangeInt.PowerOfTwo.class);
14644  private static NISuppressor arg2_power2 =
14645      new NISuppressor(0, RangeInt.PowerOfTwo.class);
14646
14647  private static NISuppressor result_and0_arg1 =
14648      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
14649  private static NISuppressor result_and0_arg2 =
14650      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
14651  private static NISuppressor arg1_and0_arg2 =
14652      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
14653
14654  // The arguments to bitwise subset are backwards from what one
14655  // might expect.  The second argument is a subset of the first
14656  // argument
14657  private static NISuppressor arg1_bw_subset_arg2 =
14658      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
14659  private static NISuppressor arg2_bw_subset_arg1 =
14660      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
14661
14662  private static NISuppressor result_shift0_arg1 =
14663      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
14664  private static NISuppressor result_shift0_arg2 =
14665      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
14666  private static NISuppressor arg1_shift0_arg2 =
14667      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
14668
14669  private static NISuppressor arg2_divides_arg1 =
14670      new NISuppressor(2, 0, NumericInt.Divides.class);
14671  private static NISuppressor arg1_divides_arg2 =
14672      new NISuppressor(0, 2, NumericInt.Divides.class);
14673
14674  private static NISuppressor arg2_valid_shift =
14675      new NISuppressor(0, RangeInt.Bound0_63.class);
14676
14677    private static NISuppressionSet suppressions =
14678        new NISuppressionSet(
14679          new NISuppression[] {
14680
14681            // (r == z) && (x == 0) ==> r = z << x
14682            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
14683
14684            // (r == 0) && (z == 0) && (0 <= x <= 63)   ==> r = z << x
14685            new NISuppression(result_eq_0, arg1_eq_0, arg2_valid_shift,
14686                               suppressee),
14687
14688          });
14689
14690  // Create a suppression factory for functionBinary
14691
14692}
14693
14694/**
14695 * Represents the invariant {@code z = Lshift(y, x)} over three long
14696 * scalars. 
14697 */
14698public static class LshiftLong_zyx extends FunctionBinary {
14699  // We are Serializable, so we specify a version to allow changes to
14700  // method signatures without breaking serialization.  If you add or
14701  // remove fields, you should change this number to the current date.
14702  static final long serialVersionUID = 20031030L;
14703
14704    // x must be between arg2_bound[0] and arg2_bound[1] inclusive
14705    static int[] arg2_bound = {0, 63};
14706
14707  private static @Prototype LshiftLong_zyx proto = new @Prototype LshiftLong_zyx ();
14708
14709  /** Returns the prototype invariant for LshiftLong_zyx */
14710  public static @Prototype LshiftLong_zyx get_proto() {
14711    return proto;
14712  }
14713
14714  /** instantiate an invariant on the specified slice */
14715  @Override
14716  protected LshiftLong_zyx instantiate_dyn(@Prototype LshiftLong_zyx this, PptSlice slice) {
14717    return new LshiftLong_zyx (slice);
14718  }
14719
14720  private LshiftLong_zyx (PptSlice slice) {
14721    super(slice);
14722  }
14723
14724  public @Prototype LshiftLong_zyx () {
14725    super();
14726  }
14727
14728  private static String[] method_name = new String[] {"", " << ", ""};
14729
14730  @Override
14731  public String[] get_method_name(@GuardSatisfied LshiftLong_zyx this) {
14732    return method_name;
14733  }
14734
14735  private static int function_id = -1;
14736
14737  @Override
14738  public int get_function_id() {
14739    return function_id;
14740  }
14741
14742  @Override
14743  public void set_function_id(int function_id) {
14744    assert LshiftLong_zyx.function_id == -1;
14745    LshiftLong_zyx.function_id = function_id;
14746  }
14747
14748  private static int var_order = 6;
14749
14750  @Override
14751  public int get_var_order(@GuardSatisfied LshiftLong_zyx this) {
14752    return var_order;
14753  }
14754
14755  @Pure
14756  @Override
14757  public boolean is_symmetric() {
14758
14759      return false;
14760  }
14761
14762  @Override
14763
14764  public long func(long y, long x) {
14765
14766      if ((x < arg2_bound[0]) || (x > arg2_bound[1])) {
14767        throw new ArithmeticException("arg2 (" + x + ") out of range "
14768                                       + arg2_bound[0] + ".." + arg2_bound[1]);
14769      }
14770
14771    return (y << x);
14772  }
14773
14774  @Override
14775  public InvariantStatus check_modified(long x, long y,
14776                                      long z, int count) {
14777    return check_ordered(z, y, x, count);
14778  }
14779
14780  @Override
14781  public InvariantStatus add_modified(long x, long y,
14782                                      long z, int count) {
14783    if (Debug.logDetail()) {
14784      log("result=%s, arg1=%s, arg2=%s", z, y, x);
14785    }
14786    return add_ordered(z, y, x, count);
14787  }
14788
14789  @Pure
14790  @Override
14791  public boolean isLshift() {
14792    return true;
14793  }
14794
14795  /** Returns a list of non-instantiating suppressions for this invariant. */
14796  @Pure
14797  @Override
14798  public @Nullable NISuppressionSet get_ni_suppressions() {
14799    if (NIS.dkconfig_enabled && dkconfig_enabled) {
14800      return suppressions;
14801    } else {
14802      return null;
14803    }
14804  }
14805
14806  /** definition of this invariant (the suppressee) */
14807  private static NISuppressee suppressee = new NISuppressee(LshiftLong_zyx.class, 3);
14808
14809  // suppressor definitions (used below)
14810  private static NISuppressor result_eq_arg1 =
14811      new NISuppressor(2, 1, IntEqual.class);
14812  private static NISuppressor result_eq_arg2 =
14813      new NISuppressor(2, 0, IntEqual.class);
14814  private static NISuppressor arg1_eq_arg2 =
14815      new NISuppressor(1, 0, IntEqual.class);
14816
14817  private static NISuppressor result_lt_arg1 =
14818      new NISuppressor(2, 1, IntLessThan.class);
14819  private static NISuppressor result_lt_arg2 =
14820      new NISuppressor(2, 0, IntLessThan.class);
14821  private static NISuppressor arg1_lt_arg2 =
14822      new NISuppressor(1, 0, IntLessThan.class);
14823  private static NISuppressor arg2_lt_arg1 =
14824      new NISuppressor(0, 1, IntLessThan.class);
14825
14826  private static NISuppressor result_le_arg1 =
14827      new NISuppressor(2, 1, IntLessEqual.class);
14828  private static NISuppressor result_le_arg2 =
14829      new NISuppressor(2, 0, IntLessEqual.class);
14830  private static NISuppressor arg1_le_arg2 =
14831      new NISuppressor(1, 0, IntLessEqual.class);
14832  private static NISuppressor arg2_le_arg1 =
14833      new NISuppressor(0, 1, IntLessEqual.class);
14834
14835  private static NISuppressor result_track0_arg1 =
14836      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
14837  private static NISuppressor result_track0_arg2 =
14838      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
14839  private static NISuppressor arg1_track0_arg2 =
14840      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
14841  private static NISuppressor arg1_track0_result =
14842      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
14843  private static NISuppressor arg2_track0_result =
14844      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
14845  private static NISuppressor arg2_track0_arg1 =
14846      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
14847
14848  private static NISuppressor result_eq_1 =
14849      new NISuppressor(2, RangeInt.EqualOne.class);
14850  private static NISuppressor arg1_eq_1 =
14851      new NISuppressor(1, RangeInt.EqualOne.class);
14852  private static NISuppressor arg2_eq_1 =
14853      new NISuppressor(0, RangeInt.EqualOne.class);
14854
14855  private static NISuppressor result_eq_0 =
14856      new NISuppressor(2, RangeInt.EqualZero.class);
14857  private static NISuppressor arg1_eq_0 =
14858      new NISuppressor(1, RangeInt.EqualZero.class);
14859  private static NISuppressor arg2_eq_0 =
14860      new NISuppressor(0, RangeInt.EqualZero.class);
14861
14862  private static NISuppressor result_ne_0 =
14863      new NISuppressor(2, NonZero.class);
14864  private static NISuppressor arg1_ne_0 =
14865      new NISuppressor(1, NonZero.class);
14866  private static NISuppressor arg2_ne_0 =
14867      new NISuppressor(0, NonZero.class);
14868
14869  private static NISuppressor result_ge_0 =
14870      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
14871  private static NISuppressor arg1_ge_0 =
14872      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
14873  private static NISuppressor arg2_ge_0 =
14874      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
14875
14876  private static NISuppressor result_ge_64 =
14877      new NISuppressor(2, RangeInt.GreaterEqual64.class);
14878  private static NISuppressor arg1_ge_64 =
14879      new NISuppressor(1, RangeInt.GreaterEqual64.class);
14880  private static NISuppressor arg2_ge_64 =
14881      new NISuppressor(0, RangeInt.GreaterEqual64.class);
14882
14883  private static NISuppressor result_boolean =
14884      new NISuppressor(2, RangeInt.BooleanVal.class);
14885  private static NISuppressor arg1_boolean =
14886      new NISuppressor(1, RangeInt.BooleanVal.class);
14887  private static NISuppressor arg2_boolean =
14888      new NISuppressor(0, RangeInt.BooleanVal.class);
14889
14890  private static NISuppressor result_even =
14891      new NISuppressor(2, RangeInt.Even.class);
14892  private static NISuppressor arg1_even =
14893      new NISuppressor(1, RangeInt.Even.class);
14894  private static NISuppressor arg2_even =
14895      new NISuppressor(0, RangeInt.Even.class);
14896
14897  private static NISuppressor result_power2 =
14898      new NISuppressor(2, RangeInt.PowerOfTwo.class);
14899  private static NISuppressor arg1_power2 =
14900      new NISuppressor(1, RangeInt.PowerOfTwo.class);
14901  private static NISuppressor arg2_power2 =
14902      new NISuppressor(0, RangeInt.PowerOfTwo.class);
14903
14904  private static NISuppressor result_and0_arg1 =
14905      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
14906  private static NISuppressor result_and0_arg2 =
14907      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
14908  private static NISuppressor arg1_and0_arg2 =
14909      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
14910
14911  // The arguments to bitwise subset are backwards from what one
14912  // might expect.  The second argument is a subset of the first
14913  // argument
14914  private static NISuppressor arg1_bw_subset_arg2 =
14915      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
14916  private static NISuppressor arg2_bw_subset_arg1 =
14917      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
14918
14919  private static NISuppressor result_shift0_arg1 =
14920      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
14921  private static NISuppressor result_shift0_arg2 =
14922      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
14923  private static NISuppressor arg1_shift0_arg2 =
14924      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
14925
14926  private static NISuppressor arg2_divides_arg1 =
14927      new NISuppressor(1, 0, NumericInt.Divides.class);
14928  private static NISuppressor arg1_divides_arg2 =
14929      new NISuppressor(0, 1, NumericInt.Divides.class);
14930
14931  private static NISuppressor arg2_valid_shift =
14932      new NISuppressor(0, RangeInt.Bound0_63.class);
14933
14934    private static NISuppressionSet suppressions =
14935        new NISuppressionSet(
14936          new NISuppression[] {
14937
14938            // (r == y) && (x == 0) ==> r = y << x
14939            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
14940
14941            // (r == 0) && (y == 0) && (0 <= x <= 63)   ==> r = y << x
14942            new NISuppression(result_eq_0, arg1_eq_0, arg2_valid_shift,
14943                               suppressee),
14944
14945          });
14946
14947  // Create a suppression factory for functionBinary
14948
14949}
14950
14951  // default is that it is not this function, overriden in the subclass
14952  @Pure
14953  public boolean isRshiftSigned() {
14954    return false;
14955  }
14956
14957/**
14958 * Represents the invariant {@code x = RshiftSigned(y, z)} over three long
14959 * scalars. 
14960 */
14961public static class RshiftSignedLong_xyz extends FunctionBinary {
14962  // We are Serializable, so we specify a version to allow changes to
14963  // method signatures without breaking serialization.  If you add or
14964  // remove fields, you should change this number to the current date.
14965  static final long serialVersionUID = 20031030L;
14966
14967    // z must be between arg2_bound[0] and arg2_bound[1] inclusive
14968    static int[] arg2_bound = {0, 63};
14969
14970  private static @Prototype RshiftSignedLong_xyz proto = new @Prototype RshiftSignedLong_xyz ();
14971
14972  /** Returns the prototype invariant for RshiftSignedLong_xyz */
14973  public static @Prototype RshiftSignedLong_xyz get_proto() {
14974    return proto;
14975  }
14976
14977  /** instantiate an invariant on the specified slice */
14978  @Override
14979  protected RshiftSignedLong_xyz instantiate_dyn(@Prototype RshiftSignedLong_xyz this, PptSlice slice) {
14980    return new RshiftSignedLong_xyz (slice);
14981  }
14982
14983  private RshiftSignedLong_xyz (PptSlice slice) {
14984    super(slice);
14985  }
14986
14987  public @Prototype RshiftSignedLong_xyz () {
14988    super();
14989  }
14990
14991  private static String[] method_name = new String[] {"", " >> ", ""};
14992
14993  @Override
14994  public String[] get_method_name(@GuardSatisfied RshiftSignedLong_xyz this) {
14995    return method_name;
14996  }
14997
14998  private static int function_id = -1;
14999
15000  @Override
15001  public int get_function_id() {
15002    return function_id;
15003  }
15004
15005  @Override
15006  public void set_function_id(int function_id) {
15007    assert RshiftSignedLong_xyz.function_id == -1;
15008    RshiftSignedLong_xyz.function_id = function_id;
15009  }
15010
15011  private static int var_order = 1;
15012
15013  @Override
15014  public int get_var_order(@GuardSatisfied RshiftSignedLong_xyz this) {
15015    return var_order;
15016  }
15017
15018  @Pure
15019  @Override
15020  public boolean is_symmetric() {
15021
15022      return false;
15023  }
15024
15025  @Override
15026
15027  public long func(long y, long z) {
15028
15029      if ((z < arg2_bound[0]) || (z > arg2_bound[1])) {
15030        throw new ArithmeticException("arg2 (" + z + ") out of range "
15031                                       + arg2_bound[0] + ".." + arg2_bound[1]);
15032      }
15033
15034    return (y >> z);
15035  }
15036
15037  @Override
15038  public InvariantStatus check_modified(long x, long y,
15039                                      long z, int count) {
15040    return check_ordered(x, y, z, count);
15041  }
15042
15043  @Override
15044  public InvariantStatus add_modified(long x, long y,
15045                                      long z, int count) {
15046    if (Debug.logDetail()) {
15047      log("result=%s, arg1=%s, arg2=%s", x, y, z);
15048    }
15049    return add_ordered(x, y, z, count);
15050  }
15051
15052  @Pure
15053  @Override
15054  public boolean isRshiftSigned() {
15055    return true;
15056  }
15057
15058  /** Returns a list of non-instantiating suppressions for this invariant. */
15059  @Pure
15060  @Override
15061  public @Nullable NISuppressionSet get_ni_suppressions() {
15062    if (NIS.dkconfig_enabled && dkconfig_enabled) {
15063      return suppressions;
15064    } else {
15065      return null;
15066    }
15067  }
15068
15069  /** definition of this invariant (the suppressee) */
15070  private static NISuppressee suppressee = new NISuppressee(RshiftSignedLong_xyz.class, 3);
15071
15072  // suppressor definitions (used below)
15073  private static NISuppressor result_eq_arg1 =
15074      new NISuppressor(0, 1, IntEqual.class);
15075  private static NISuppressor result_eq_arg2 =
15076      new NISuppressor(0, 2, IntEqual.class);
15077  private static NISuppressor arg1_eq_arg2 =
15078      new NISuppressor(1, 2, IntEqual.class);
15079
15080  private static NISuppressor result_lt_arg1 =
15081      new NISuppressor(0, 1, IntLessThan.class);
15082  private static NISuppressor result_lt_arg2 =
15083      new NISuppressor(0, 2, IntLessThan.class);
15084  private static NISuppressor arg1_lt_arg2 =
15085      new NISuppressor(1, 2, IntLessThan.class);
15086  private static NISuppressor arg2_lt_arg1 =
15087      new NISuppressor(2, 1, IntLessThan.class);
15088
15089  private static NISuppressor result_le_arg1 =
15090      new NISuppressor(0, 1, IntLessEqual.class);
15091  private static NISuppressor result_le_arg2 =
15092      new NISuppressor(0, 2, IntLessEqual.class);
15093  private static NISuppressor arg1_le_arg2 =
15094      new NISuppressor(1, 2, IntLessEqual.class);
15095  private static NISuppressor arg2_le_arg1 =
15096      new NISuppressor(2, 1, IntLessEqual.class);
15097
15098  private static NISuppressor result_track0_arg1 =
15099      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
15100  private static NISuppressor result_track0_arg2 =
15101      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
15102  private static NISuppressor arg1_track0_arg2 =
15103      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
15104  private static NISuppressor arg1_track0_result =
15105      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
15106  private static NISuppressor arg2_track0_result =
15107      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
15108  private static NISuppressor arg2_track0_arg1 =
15109      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
15110
15111  private static NISuppressor result_eq_1 =
15112      new NISuppressor(0, RangeInt.EqualOne.class);
15113  private static NISuppressor arg1_eq_1 =
15114      new NISuppressor(1, RangeInt.EqualOne.class);
15115  private static NISuppressor arg2_eq_1 =
15116      new NISuppressor(2, RangeInt.EqualOne.class);
15117
15118  private static NISuppressor result_eq_0 =
15119      new NISuppressor(0, RangeInt.EqualZero.class);
15120  private static NISuppressor arg1_eq_0 =
15121      new NISuppressor(1, RangeInt.EqualZero.class);
15122  private static NISuppressor arg2_eq_0 =
15123      new NISuppressor(2, RangeInt.EqualZero.class);
15124
15125  private static NISuppressor result_ne_0 =
15126      new NISuppressor(0, NonZero.class);
15127  private static NISuppressor arg1_ne_0 =
15128      new NISuppressor(1, NonZero.class);
15129  private static NISuppressor arg2_ne_0 =
15130      new NISuppressor(2, NonZero.class);
15131
15132  private static NISuppressor result_ge_0 =
15133      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
15134  private static NISuppressor arg1_ge_0 =
15135      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
15136  private static NISuppressor arg2_ge_0 =
15137      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
15138
15139  private static NISuppressor result_ge_64 =
15140      new NISuppressor(0, RangeInt.GreaterEqual64.class);
15141  private static NISuppressor arg1_ge_64 =
15142      new NISuppressor(1, RangeInt.GreaterEqual64.class);
15143  private static NISuppressor arg2_ge_64 =
15144      new NISuppressor(2, RangeInt.GreaterEqual64.class);
15145
15146  private static NISuppressor result_boolean =
15147      new NISuppressor(0, RangeInt.BooleanVal.class);
15148  private static NISuppressor arg1_boolean =
15149      new NISuppressor(1, RangeInt.BooleanVal.class);
15150  private static NISuppressor arg2_boolean =
15151      new NISuppressor(2, RangeInt.BooleanVal.class);
15152
15153  private static NISuppressor result_even =
15154      new NISuppressor(0, RangeInt.Even.class);
15155  private static NISuppressor arg1_even =
15156      new NISuppressor(1, RangeInt.Even.class);
15157  private static NISuppressor arg2_even =
15158      new NISuppressor(2, RangeInt.Even.class);
15159
15160  private static NISuppressor result_power2 =
15161      new NISuppressor(0, RangeInt.PowerOfTwo.class);
15162  private static NISuppressor arg1_power2 =
15163      new NISuppressor(1, RangeInt.PowerOfTwo.class);
15164  private static NISuppressor arg2_power2 =
15165      new NISuppressor(2, RangeInt.PowerOfTwo.class);
15166
15167  private static NISuppressor result_and0_arg1 =
15168      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
15169  private static NISuppressor result_and0_arg2 =
15170      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
15171  private static NISuppressor arg1_and0_arg2 =
15172      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
15173
15174  // The arguments to bitwise subset are backwards from what one
15175  // might expect.  The second argument is a subset of the first
15176  // argument
15177  private static NISuppressor arg1_bw_subset_arg2 =
15178      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
15179  private static NISuppressor arg2_bw_subset_arg1 =
15180      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
15181
15182  private static NISuppressor result_shift0_arg1 =
15183      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
15184  private static NISuppressor result_shift0_arg2 =
15185      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
15186  private static NISuppressor arg1_shift0_arg2 =
15187      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
15188
15189  private static NISuppressor arg2_divides_arg1 =
15190      new NISuppressor(1, 2, NumericInt.Divides.class);
15191  private static NISuppressor arg1_divides_arg2 =
15192      new NISuppressor(2, 1, NumericInt.Divides.class);
15193
15194  private static NISuppressor arg2_valid_shift =
15195      new NISuppressor(2, RangeInt.Bound0_63.class);
15196
15197    private static NISuppressionSet suppressions =
15198        new NISuppressionSet(
15199          new NISuppression[] {
15200
15201            // (r == y) && (z == 0) ==> r = y >>> z
15202            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
15203
15204            // (r == 0) && (y == 0) && (0 <= z <= 63)   ==> r = y >>> z
15205            // new NISuppression (result_eq_0, arg1_eq_0, arg2_valid_shift, suppressee),
15206
15207            // (r == 0) && ((y >> z) == 0)
15208            new NISuppression(result_eq_0, arg1_shift0_arg2, suppressee),
15209
15210            // (r == 0) && (z >= y) && (y >= 0) && (z valid shift)
15211            // This suppression really ought to have 2**z >= y, but we
15212            // don't have that invariant.  This still might catch a lot of these.
15213            // new NISuppression (result_eq_0, arg1_le_arg2, arg1_ge_0,
15214            //                   arg2_valid_shift, suppressee),
15215          });
15216
15217  // Create a suppression factory for functionBinary
15218
15219}
15220
15221/**
15222 * Represents the invariant {@code y = RshiftSigned(x, z)} over three long
15223 * scalars. 
15224 */
15225public static class RshiftSignedLong_yxz extends FunctionBinary {
15226  // We are Serializable, so we specify a version to allow changes to
15227  // method signatures without breaking serialization.  If you add or
15228  // remove fields, you should change this number to the current date.
15229  static final long serialVersionUID = 20031030L;
15230
15231    // z must be between arg2_bound[0] and arg2_bound[1] inclusive
15232    static int[] arg2_bound = {0, 63};
15233
15234  private static @Prototype RshiftSignedLong_yxz proto = new @Prototype RshiftSignedLong_yxz ();
15235
15236  /** Returns the prototype invariant for RshiftSignedLong_yxz */
15237  public static @Prototype RshiftSignedLong_yxz get_proto() {
15238    return proto;
15239  }
15240
15241  /** instantiate an invariant on the specified slice */
15242  @Override
15243  protected RshiftSignedLong_yxz instantiate_dyn(@Prototype RshiftSignedLong_yxz this, PptSlice slice) {
15244    return new RshiftSignedLong_yxz (slice);
15245  }
15246
15247  private RshiftSignedLong_yxz (PptSlice slice) {
15248    super(slice);
15249  }
15250
15251  public @Prototype RshiftSignedLong_yxz () {
15252    super();
15253  }
15254
15255  private static String[] method_name = new String[] {"", " >> ", ""};
15256
15257  @Override
15258  public String[] get_method_name(@GuardSatisfied RshiftSignedLong_yxz this) {
15259    return method_name;
15260  }
15261
15262  private static int function_id = -1;
15263
15264  @Override
15265  public int get_function_id() {
15266    return function_id;
15267  }
15268
15269  @Override
15270  public void set_function_id(int function_id) {
15271    assert RshiftSignedLong_yxz.function_id == -1;
15272    RshiftSignedLong_yxz.function_id = function_id;
15273  }
15274
15275  private static int var_order = 2;
15276
15277  @Override
15278  public int get_var_order(@GuardSatisfied RshiftSignedLong_yxz this) {
15279    return var_order;
15280  }
15281
15282  @Pure
15283  @Override
15284  public boolean is_symmetric() {
15285
15286      return false;
15287  }
15288
15289  @Override
15290
15291  public long func(long x, long z) {
15292
15293      if ((z < arg2_bound[0]) || (z > arg2_bound[1])) {
15294        throw new ArithmeticException("arg2 (" + z + ") out of range "
15295                                       + arg2_bound[0] + ".." + arg2_bound[1]);
15296      }
15297
15298    return (x >> z);
15299  }
15300
15301  @Override
15302  public InvariantStatus check_modified(long x, long y,
15303                                      long z, int count) {
15304    return check_ordered(y, x, z, count);
15305  }
15306
15307  @Override
15308  public InvariantStatus add_modified(long x, long y,
15309                                      long z, int count) {
15310    if (Debug.logDetail()) {
15311      log("result=%s, arg1=%s, arg2=%s", y, x, z);
15312    }
15313    return add_ordered(y, x, z, count);
15314  }
15315
15316  @Pure
15317  @Override
15318  public boolean isRshiftSigned() {
15319    return true;
15320  }
15321
15322  /** Returns a list of non-instantiating suppressions for this invariant. */
15323  @Pure
15324  @Override
15325  public @Nullable NISuppressionSet get_ni_suppressions() {
15326    if (NIS.dkconfig_enabled && dkconfig_enabled) {
15327      return suppressions;
15328    } else {
15329      return null;
15330    }
15331  }
15332
15333  /** definition of this invariant (the suppressee) */
15334  private static NISuppressee suppressee = new NISuppressee(RshiftSignedLong_yxz.class, 3);
15335
15336  // suppressor definitions (used below)
15337  private static NISuppressor result_eq_arg1 =
15338      new NISuppressor(1, 0, IntEqual.class);
15339  private static NISuppressor result_eq_arg2 =
15340      new NISuppressor(1, 2, IntEqual.class);
15341  private static NISuppressor arg1_eq_arg2 =
15342      new NISuppressor(0, 2, IntEqual.class);
15343
15344  private static NISuppressor result_lt_arg1 =
15345      new NISuppressor(1, 0, IntLessThan.class);
15346  private static NISuppressor result_lt_arg2 =
15347      new NISuppressor(1, 2, IntLessThan.class);
15348  private static NISuppressor arg1_lt_arg2 =
15349      new NISuppressor(0, 2, IntLessThan.class);
15350  private static NISuppressor arg2_lt_arg1 =
15351      new NISuppressor(2, 0, IntLessThan.class);
15352
15353  private static NISuppressor result_le_arg1 =
15354      new NISuppressor(1, 0, IntLessEqual.class);
15355  private static NISuppressor result_le_arg2 =
15356      new NISuppressor(1, 2, IntLessEqual.class);
15357  private static NISuppressor arg1_le_arg2 =
15358      new NISuppressor(0, 2, IntLessEqual.class);
15359  private static NISuppressor arg2_le_arg1 =
15360      new NISuppressor(2, 0, IntLessEqual.class);
15361
15362  private static NISuppressor result_track0_arg1 =
15363      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
15364  private static NISuppressor result_track0_arg2 =
15365      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
15366  private static NISuppressor arg1_track0_arg2 =
15367      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
15368  private static NISuppressor arg1_track0_result =
15369      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
15370  private static NISuppressor arg2_track0_result =
15371      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
15372  private static NISuppressor arg2_track0_arg1 =
15373      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
15374
15375  private static NISuppressor result_eq_1 =
15376      new NISuppressor(1, RangeInt.EqualOne.class);
15377  private static NISuppressor arg1_eq_1 =
15378      new NISuppressor(0, RangeInt.EqualOne.class);
15379  private static NISuppressor arg2_eq_1 =
15380      new NISuppressor(2, RangeInt.EqualOne.class);
15381
15382  private static NISuppressor result_eq_0 =
15383      new NISuppressor(1, RangeInt.EqualZero.class);
15384  private static NISuppressor arg1_eq_0 =
15385      new NISuppressor(0, RangeInt.EqualZero.class);
15386  private static NISuppressor arg2_eq_0 =
15387      new NISuppressor(2, RangeInt.EqualZero.class);
15388
15389  private static NISuppressor result_ne_0 =
15390      new NISuppressor(1, NonZero.class);
15391  private static NISuppressor arg1_ne_0 =
15392      new NISuppressor(0, NonZero.class);
15393  private static NISuppressor arg2_ne_0 =
15394      new NISuppressor(2, NonZero.class);
15395
15396  private static NISuppressor result_ge_0 =
15397      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
15398  private static NISuppressor arg1_ge_0 =
15399      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
15400  private static NISuppressor arg2_ge_0 =
15401      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
15402
15403  private static NISuppressor result_ge_64 =
15404      new NISuppressor(1, RangeInt.GreaterEqual64.class);
15405  private static NISuppressor arg1_ge_64 =
15406      new NISuppressor(0, RangeInt.GreaterEqual64.class);
15407  private static NISuppressor arg2_ge_64 =
15408      new NISuppressor(2, RangeInt.GreaterEqual64.class);
15409
15410  private static NISuppressor result_boolean =
15411      new NISuppressor(1, RangeInt.BooleanVal.class);
15412  private static NISuppressor arg1_boolean =
15413      new NISuppressor(0, RangeInt.BooleanVal.class);
15414  private static NISuppressor arg2_boolean =
15415      new NISuppressor(2, RangeInt.BooleanVal.class);
15416
15417  private static NISuppressor result_even =
15418      new NISuppressor(1, RangeInt.Even.class);
15419  private static NISuppressor arg1_even =
15420      new NISuppressor(0, RangeInt.Even.class);
15421  private static NISuppressor arg2_even =
15422      new NISuppressor(2, RangeInt.Even.class);
15423
15424  private static NISuppressor result_power2 =
15425      new NISuppressor(1, RangeInt.PowerOfTwo.class);
15426  private static NISuppressor arg1_power2 =
15427      new NISuppressor(0, RangeInt.PowerOfTwo.class);
15428  private static NISuppressor arg2_power2 =
15429      new NISuppressor(2, RangeInt.PowerOfTwo.class);
15430
15431  private static NISuppressor result_and0_arg1 =
15432      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
15433  private static NISuppressor result_and0_arg2 =
15434      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
15435  private static NISuppressor arg1_and0_arg2 =
15436      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
15437
15438  // The arguments to bitwise subset are backwards from what one
15439  // might expect.  The second argument is a subset of the first
15440  // argument
15441  private static NISuppressor arg1_bw_subset_arg2 =
15442      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
15443  private static NISuppressor arg2_bw_subset_arg1 =
15444      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
15445
15446  private static NISuppressor result_shift0_arg1 =
15447      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
15448  private static NISuppressor result_shift0_arg2 =
15449      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
15450  private static NISuppressor arg1_shift0_arg2 =
15451      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
15452
15453  private static NISuppressor arg2_divides_arg1 =
15454      new NISuppressor(0, 2, NumericInt.Divides.class);
15455  private static NISuppressor arg1_divides_arg2 =
15456      new NISuppressor(2, 0, NumericInt.Divides.class);
15457
15458  private static NISuppressor arg2_valid_shift =
15459      new NISuppressor(2, RangeInt.Bound0_63.class);
15460
15461    private static NISuppressionSet suppressions =
15462        new NISuppressionSet(
15463          new NISuppression[] {
15464
15465            // (r == x) && (z == 0) ==> r = x >>> z
15466            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
15467
15468            // (r == 0) && (x == 0) && (0 <= z <= 63)   ==> r = x >>> z
15469            // new NISuppression (result_eq_0, arg1_eq_0, arg2_valid_shift, suppressee),
15470
15471            // (r == 0) && ((x >> z) == 0)
15472            new NISuppression(result_eq_0, arg1_shift0_arg2, suppressee),
15473
15474            // (r == 0) && (z >= x) && (x >= 0) && (z valid shift)
15475            // This suppression really ought to have 2**z >= x, but we
15476            // don't have that invariant.  This still might catch a lot of these.
15477            // new NISuppression (result_eq_0, arg1_le_arg2, arg1_ge_0,
15478            //                   arg2_valid_shift, suppressee),
15479          });
15480
15481  // Create a suppression factory for functionBinary
15482
15483}
15484
15485/**
15486 * Represents the invariant {@code z = RshiftSigned(x, y)} over three long
15487 * scalars. 
15488 */
15489public static class RshiftSignedLong_zxy extends FunctionBinary {
15490  // We are Serializable, so we specify a version to allow changes to
15491  // method signatures without breaking serialization.  If you add or
15492  // remove fields, you should change this number to the current date.
15493  static final long serialVersionUID = 20031030L;
15494
15495    // y must be between arg2_bound[0] and arg2_bound[1] inclusive
15496    static int[] arg2_bound = {0, 63};
15497
15498  private static @Prototype RshiftSignedLong_zxy proto = new @Prototype RshiftSignedLong_zxy ();
15499
15500  /** Returns the prototype invariant for RshiftSignedLong_zxy */
15501  public static @Prototype RshiftSignedLong_zxy get_proto() {
15502    return proto;
15503  }
15504
15505  /** instantiate an invariant on the specified slice */
15506  @Override
15507  protected RshiftSignedLong_zxy instantiate_dyn(@Prototype RshiftSignedLong_zxy this, PptSlice slice) {
15508    return new RshiftSignedLong_zxy (slice);
15509  }
15510
15511  private RshiftSignedLong_zxy (PptSlice slice) {
15512    super(slice);
15513  }
15514
15515  public @Prototype RshiftSignedLong_zxy () {
15516    super();
15517  }
15518
15519  private static String[] method_name = new String[] {"", " >> ", ""};
15520
15521  @Override
15522  public String[] get_method_name(@GuardSatisfied RshiftSignedLong_zxy this) {
15523    return method_name;
15524  }
15525
15526  private static int function_id = -1;
15527
15528  @Override
15529  public int get_function_id() {
15530    return function_id;
15531  }
15532
15533  @Override
15534  public void set_function_id(int function_id) {
15535    assert RshiftSignedLong_zxy.function_id == -1;
15536    RshiftSignedLong_zxy.function_id = function_id;
15537  }
15538
15539  private static int var_order = 3;
15540
15541  @Override
15542  public int get_var_order(@GuardSatisfied RshiftSignedLong_zxy this) {
15543    return var_order;
15544  }
15545
15546  @Pure
15547  @Override
15548  public boolean is_symmetric() {
15549
15550      return false;
15551  }
15552
15553  @Override
15554
15555  public long func(long x, long y) {
15556
15557      if ((y < arg2_bound[0]) || (y > arg2_bound[1])) {
15558        throw new ArithmeticException("arg2 (" + y + ") out of range "
15559                                       + arg2_bound[0] + ".." + arg2_bound[1]);
15560      }
15561
15562    return (x >> y);
15563  }
15564
15565  @Override
15566  public InvariantStatus check_modified(long x, long y,
15567                                      long z, int count) {
15568    return check_ordered(z, x, y, count);
15569  }
15570
15571  @Override
15572  public InvariantStatus add_modified(long x, long y,
15573                                      long z, int count) {
15574    if (Debug.logDetail()) {
15575      log("result=%s, arg1=%s, arg2=%s", z, x, y);
15576    }
15577    return add_ordered(z, x, y, count);
15578  }
15579
15580  @Pure
15581  @Override
15582  public boolean isRshiftSigned() {
15583    return true;
15584  }
15585
15586  /** Returns a list of non-instantiating suppressions for this invariant. */
15587  @Pure
15588  @Override
15589  public @Nullable NISuppressionSet get_ni_suppressions() {
15590    if (NIS.dkconfig_enabled && dkconfig_enabled) {
15591      return suppressions;
15592    } else {
15593      return null;
15594    }
15595  }
15596
15597  /** definition of this invariant (the suppressee) */
15598  private static NISuppressee suppressee = new NISuppressee(RshiftSignedLong_zxy.class, 3);
15599
15600  // suppressor definitions (used below)
15601  private static NISuppressor result_eq_arg1 =
15602      new NISuppressor(2, 0, IntEqual.class);
15603  private static NISuppressor result_eq_arg2 =
15604      new NISuppressor(2, 1, IntEqual.class);
15605  private static NISuppressor arg1_eq_arg2 =
15606      new NISuppressor(0, 1, IntEqual.class);
15607
15608  private static NISuppressor result_lt_arg1 =
15609      new NISuppressor(2, 0, IntLessThan.class);
15610  private static NISuppressor result_lt_arg2 =
15611      new NISuppressor(2, 1, IntLessThan.class);
15612  private static NISuppressor arg1_lt_arg2 =
15613      new NISuppressor(0, 1, IntLessThan.class);
15614  private static NISuppressor arg2_lt_arg1 =
15615      new NISuppressor(1, 0, IntLessThan.class);
15616
15617  private static NISuppressor result_le_arg1 =
15618      new NISuppressor(2, 0, IntLessEqual.class);
15619  private static NISuppressor result_le_arg2 =
15620      new NISuppressor(2, 1, IntLessEqual.class);
15621  private static NISuppressor arg1_le_arg2 =
15622      new NISuppressor(0, 1, IntLessEqual.class);
15623  private static NISuppressor arg2_le_arg1 =
15624      new NISuppressor(1, 0, IntLessEqual.class);
15625
15626  private static NISuppressor result_track0_arg1 =
15627      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
15628  private static NISuppressor result_track0_arg2 =
15629      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
15630  private static NISuppressor arg1_track0_arg2 =
15631      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
15632  private static NISuppressor arg1_track0_result =
15633      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
15634  private static NISuppressor arg2_track0_result =
15635      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
15636  private static NISuppressor arg2_track0_arg1 =
15637      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
15638
15639  private static NISuppressor result_eq_1 =
15640      new NISuppressor(2, RangeInt.EqualOne.class);
15641  private static NISuppressor arg1_eq_1 =
15642      new NISuppressor(0, RangeInt.EqualOne.class);
15643  private static NISuppressor arg2_eq_1 =
15644      new NISuppressor(1, RangeInt.EqualOne.class);
15645
15646  private static NISuppressor result_eq_0 =
15647      new NISuppressor(2, RangeInt.EqualZero.class);
15648  private static NISuppressor arg1_eq_0 =
15649      new NISuppressor(0, RangeInt.EqualZero.class);
15650  private static NISuppressor arg2_eq_0 =
15651      new NISuppressor(1, RangeInt.EqualZero.class);
15652
15653  private static NISuppressor result_ne_0 =
15654      new NISuppressor(2, NonZero.class);
15655  private static NISuppressor arg1_ne_0 =
15656      new NISuppressor(0, NonZero.class);
15657  private static NISuppressor arg2_ne_0 =
15658      new NISuppressor(1, NonZero.class);
15659
15660  private static NISuppressor result_ge_0 =
15661      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
15662  private static NISuppressor arg1_ge_0 =
15663      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
15664  private static NISuppressor arg2_ge_0 =
15665      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
15666
15667  private static NISuppressor result_ge_64 =
15668      new NISuppressor(2, RangeInt.GreaterEqual64.class);
15669  private static NISuppressor arg1_ge_64 =
15670      new NISuppressor(0, RangeInt.GreaterEqual64.class);
15671  private static NISuppressor arg2_ge_64 =
15672      new NISuppressor(1, RangeInt.GreaterEqual64.class);
15673
15674  private static NISuppressor result_boolean =
15675      new NISuppressor(2, RangeInt.BooleanVal.class);
15676  private static NISuppressor arg1_boolean =
15677      new NISuppressor(0, RangeInt.BooleanVal.class);
15678  private static NISuppressor arg2_boolean =
15679      new NISuppressor(1, RangeInt.BooleanVal.class);
15680
15681  private static NISuppressor result_even =
15682      new NISuppressor(2, RangeInt.Even.class);
15683  private static NISuppressor arg1_even =
15684      new NISuppressor(0, RangeInt.Even.class);
15685  private static NISuppressor arg2_even =
15686      new NISuppressor(1, RangeInt.Even.class);
15687
15688  private static NISuppressor result_power2 =
15689      new NISuppressor(2, RangeInt.PowerOfTwo.class);
15690  private static NISuppressor arg1_power2 =
15691      new NISuppressor(0, RangeInt.PowerOfTwo.class);
15692  private static NISuppressor arg2_power2 =
15693      new NISuppressor(1, RangeInt.PowerOfTwo.class);
15694
15695  private static NISuppressor result_and0_arg1 =
15696      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
15697  private static NISuppressor result_and0_arg2 =
15698      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
15699  private static NISuppressor arg1_and0_arg2 =
15700      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
15701
15702  // The arguments to bitwise subset are backwards from what one
15703  // might expect.  The second argument is a subset of the first
15704  // argument
15705  private static NISuppressor arg1_bw_subset_arg2 =
15706      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
15707  private static NISuppressor arg2_bw_subset_arg1 =
15708      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
15709
15710  private static NISuppressor result_shift0_arg1 =
15711      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
15712  private static NISuppressor result_shift0_arg2 =
15713      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
15714  private static NISuppressor arg1_shift0_arg2 =
15715      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
15716
15717  private static NISuppressor arg2_divides_arg1 =
15718      new NISuppressor(0, 1, NumericInt.Divides.class);
15719  private static NISuppressor arg1_divides_arg2 =
15720      new NISuppressor(1, 0, NumericInt.Divides.class);
15721
15722  private static NISuppressor arg2_valid_shift =
15723      new NISuppressor(1, RangeInt.Bound0_63.class);
15724
15725    private static NISuppressionSet suppressions =
15726        new NISuppressionSet(
15727          new NISuppression[] {
15728
15729            // (r == x) && (y == 0) ==> r = x >>> y
15730            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
15731
15732            // (r == 0) && (x == 0) && (0 <= y <= 63)   ==> r = x >>> y
15733            // new NISuppression (result_eq_0, arg1_eq_0, arg2_valid_shift, suppressee),
15734
15735            // (r == 0) && ((x >> y) == 0)
15736            new NISuppression(result_eq_0, arg1_shift0_arg2, suppressee),
15737
15738            // (r == 0) && (y >= x) && (x >= 0) && (y valid shift)
15739            // This suppression really ought to have 2**y >= x, but we
15740            // don't have that invariant.  This still might catch a lot of these.
15741            // new NISuppression (result_eq_0, arg1_le_arg2, arg1_ge_0,
15742            //                   arg2_valid_shift, suppressee),
15743          });
15744
15745  // Create a suppression factory for functionBinary
15746
15747}
15748
15749/**
15750 * Represents the invariant {@code x = RshiftSigned(z, y)} over three long
15751 * scalars. 
15752 */
15753public static class RshiftSignedLong_xzy extends FunctionBinary {
15754  // We are Serializable, so we specify a version to allow changes to
15755  // method signatures without breaking serialization.  If you add or
15756  // remove fields, you should change this number to the current date.
15757  static final long serialVersionUID = 20031030L;
15758
15759    // y must be between arg2_bound[0] and arg2_bound[1] inclusive
15760    static int[] arg2_bound = {0, 63};
15761
15762  private static @Prototype RshiftSignedLong_xzy proto = new @Prototype RshiftSignedLong_xzy ();
15763
15764  /** Returns the prototype invariant for RshiftSignedLong_xzy */
15765  public static @Prototype RshiftSignedLong_xzy get_proto() {
15766    return proto;
15767  }
15768
15769  /** instantiate an invariant on the specified slice */
15770  @Override
15771  protected RshiftSignedLong_xzy instantiate_dyn(@Prototype RshiftSignedLong_xzy this, PptSlice slice) {
15772    return new RshiftSignedLong_xzy (slice);
15773  }
15774
15775  private RshiftSignedLong_xzy (PptSlice slice) {
15776    super(slice);
15777  }
15778
15779  public @Prototype RshiftSignedLong_xzy () {
15780    super();
15781  }
15782
15783  private static String[] method_name = new String[] {"", " >> ", ""};
15784
15785  @Override
15786  public String[] get_method_name(@GuardSatisfied RshiftSignedLong_xzy this) {
15787    return method_name;
15788  }
15789
15790  private static int function_id = -1;
15791
15792  @Override
15793  public int get_function_id() {
15794    return function_id;
15795  }
15796
15797  @Override
15798  public void set_function_id(int function_id) {
15799    assert RshiftSignedLong_xzy.function_id == -1;
15800    RshiftSignedLong_xzy.function_id = function_id;
15801  }
15802
15803  private static int var_order = 4;
15804
15805  @Override
15806  public int get_var_order(@GuardSatisfied RshiftSignedLong_xzy this) {
15807    return var_order;
15808  }
15809
15810  @Pure
15811  @Override
15812  public boolean is_symmetric() {
15813
15814      return false;
15815  }
15816
15817  @Override
15818
15819  public long func(long z, long y) {
15820
15821      if ((y < arg2_bound[0]) || (y > arg2_bound[1])) {
15822        throw new ArithmeticException("arg2 (" + y + ") out of range "
15823                                       + arg2_bound[0] + ".." + arg2_bound[1]);
15824      }
15825
15826    return (z >> y);
15827  }
15828
15829  @Override
15830  public InvariantStatus check_modified(long x, long y,
15831                                      long z, int count) {
15832    return check_ordered(x, z, y, count);
15833  }
15834
15835  @Override
15836  public InvariantStatus add_modified(long x, long y,
15837                                      long z, int count) {
15838    if (Debug.logDetail()) {
15839      log("result=%s, arg1=%s, arg2=%s", x, z, y);
15840    }
15841    return add_ordered(x, z, y, count);
15842  }
15843
15844  @Pure
15845  @Override
15846  public boolean isRshiftSigned() {
15847    return true;
15848  }
15849
15850  /** Returns a list of non-instantiating suppressions for this invariant. */
15851  @Pure
15852  @Override
15853  public @Nullable NISuppressionSet get_ni_suppressions() {
15854    if (NIS.dkconfig_enabled && dkconfig_enabled) {
15855      return suppressions;
15856    } else {
15857      return null;
15858    }
15859  }
15860
15861  /** definition of this invariant (the suppressee) */
15862  private static NISuppressee suppressee = new NISuppressee(RshiftSignedLong_xzy.class, 3);
15863
15864  // suppressor definitions (used below)
15865  private static NISuppressor result_eq_arg1 =
15866      new NISuppressor(0, 2, IntEqual.class);
15867  private static NISuppressor result_eq_arg2 =
15868      new NISuppressor(0, 1, IntEqual.class);
15869  private static NISuppressor arg1_eq_arg2 =
15870      new NISuppressor(2, 1, IntEqual.class);
15871
15872  private static NISuppressor result_lt_arg1 =
15873      new NISuppressor(0, 2, IntLessThan.class);
15874  private static NISuppressor result_lt_arg2 =
15875      new NISuppressor(0, 1, IntLessThan.class);
15876  private static NISuppressor arg1_lt_arg2 =
15877      new NISuppressor(2, 1, IntLessThan.class);
15878  private static NISuppressor arg2_lt_arg1 =
15879      new NISuppressor(1, 2, IntLessThan.class);
15880
15881  private static NISuppressor result_le_arg1 =
15882      new NISuppressor(0, 2, IntLessEqual.class);
15883  private static NISuppressor result_le_arg2 =
15884      new NISuppressor(0, 1, IntLessEqual.class);
15885  private static NISuppressor arg1_le_arg2 =
15886      new NISuppressor(2, 1, IntLessEqual.class);
15887  private static NISuppressor arg2_le_arg1 =
15888      new NISuppressor(1, 2, IntLessEqual.class);
15889
15890  private static NISuppressor result_track0_arg1 =
15891      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
15892  private static NISuppressor result_track0_arg2 =
15893      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
15894  private static NISuppressor arg1_track0_arg2 =
15895      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
15896  private static NISuppressor arg1_track0_result =
15897      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
15898  private static NISuppressor arg2_track0_result =
15899      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
15900  private static NISuppressor arg2_track0_arg1 =
15901      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
15902
15903  private static NISuppressor result_eq_1 =
15904      new NISuppressor(0, RangeInt.EqualOne.class);
15905  private static NISuppressor arg1_eq_1 =
15906      new NISuppressor(2, RangeInt.EqualOne.class);
15907  private static NISuppressor arg2_eq_1 =
15908      new NISuppressor(1, RangeInt.EqualOne.class);
15909
15910  private static NISuppressor result_eq_0 =
15911      new NISuppressor(0, RangeInt.EqualZero.class);
15912  private static NISuppressor arg1_eq_0 =
15913      new NISuppressor(2, RangeInt.EqualZero.class);
15914  private static NISuppressor arg2_eq_0 =
15915      new NISuppressor(1, RangeInt.EqualZero.class);
15916
15917  private static NISuppressor result_ne_0 =
15918      new NISuppressor(0, NonZero.class);
15919  private static NISuppressor arg1_ne_0 =
15920      new NISuppressor(2, NonZero.class);
15921  private static NISuppressor arg2_ne_0 =
15922      new NISuppressor(1, NonZero.class);
15923
15924  private static NISuppressor result_ge_0 =
15925      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
15926  private static NISuppressor arg1_ge_0 =
15927      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
15928  private static NISuppressor arg2_ge_0 =
15929      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
15930
15931  private static NISuppressor result_ge_64 =
15932      new NISuppressor(0, RangeInt.GreaterEqual64.class);
15933  private static NISuppressor arg1_ge_64 =
15934      new NISuppressor(2, RangeInt.GreaterEqual64.class);
15935  private static NISuppressor arg2_ge_64 =
15936      new NISuppressor(1, RangeInt.GreaterEqual64.class);
15937
15938  private static NISuppressor result_boolean =
15939      new NISuppressor(0, RangeInt.BooleanVal.class);
15940  private static NISuppressor arg1_boolean =
15941      new NISuppressor(2, RangeInt.BooleanVal.class);
15942  private static NISuppressor arg2_boolean =
15943      new NISuppressor(1, RangeInt.BooleanVal.class);
15944
15945  private static NISuppressor result_even =
15946      new NISuppressor(0, RangeInt.Even.class);
15947  private static NISuppressor arg1_even =
15948      new NISuppressor(2, RangeInt.Even.class);
15949  private static NISuppressor arg2_even =
15950      new NISuppressor(1, RangeInt.Even.class);
15951
15952  private static NISuppressor result_power2 =
15953      new NISuppressor(0, RangeInt.PowerOfTwo.class);
15954  private static NISuppressor arg1_power2 =
15955      new NISuppressor(2, RangeInt.PowerOfTwo.class);
15956  private static NISuppressor arg2_power2 =
15957      new NISuppressor(1, RangeInt.PowerOfTwo.class);
15958
15959  private static NISuppressor result_and0_arg1 =
15960      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
15961  private static NISuppressor result_and0_arg2 =
15962      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
15963  private static NISuppressor arg1_and0_arg2 =
15964      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
15965
15966  // The arguments to bitwise subset are backwards from what one
15967  // might expect.  The second argument is a subset of the first
15968  // argument
15969  private static NISuppressor arg1_bw_subset_arg2 =
15970      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
15971  private static NISuppressor arg2_bw_subset_arg1 =
15972      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
15973
15974  private static NISuppressor result_shift0_arg1 =
15975      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
15976  private static NISuppressor result_shift0_arg2 =
15977      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
15978  private static NISuppressor arg1_shift0_arg2 =
15979      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
15980
15981  private static NISuppressor arg2_divides_arg1 =
15982      new NISuppressor(2, 1, NumericInt.Divides.class);
15983  private static NISuppressor arg1_divides_arg2 =
15984      new NISuppressor(1, 2, NumericInt.Divides.class);
15985
15986  private static NISuppressor arg2_valid_shift =
15987      new NISuppressor(1, RangeInt.Bound0_63.class);
15988
15989    private static NISuppressionSet suppressions =
15990        new NISuppressionSet(
15991          new NISuppression[] {
15992
15993            // (r == z) && (y == 0) ==> r = z >>> y
15994            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
15995
15996            // (r == 0) && (z == 0) && (0 <= y <= 63)   ==> r = z >>> y
15997            // new NISuppression (result_eq_0, arg1_eq_0, arg2_valid_shift, suppressee),
15998
15999            // (r == 0) && ((z >> y) == 0)
16000            new NISuppression(result_eq_0, arg1_shift0_arg2, suppressee),
16001
16002            // (r == 0) && (y >= z) && (z >= 0) && (y valid shift)
16003            // This suppression really ought to have 2**y >= z, but we
16004            // don't have that invariant.  This still might catch a lot of these.
16005            // new NISuppression (result_eq_0, arg1_le_arg2, arg1_ge_0,
16006            //                   arg2_valid_shift, suppressee),
16007          });
16008
16009  // Create a suppression factory for functionBinary
16010
16011}
16012
16013/**
16014 * Represents the invariant {@code y = RshiftSigned(z, x)} over three long
16015 * scalars. 
16016 */
16017public static class RshiftSignedLong_yzx extends FunctionBinary {
16018  // We are Serializable, so we specify a version to allow changes to
16019  // method signatures without breaking serialization.  If you add or
16020  // remove fields, you should change this number to the current date.
16021  static final long serialVersionUID = 20031030L;
16022
16023    // x must be between arg2_bound[0] and arg2_bound[1] inclusive
16024    static int[] arg2_bound = {0, 63};
16025
16026  private static @Prototype RshiftSignedLong_yzx proto = new @Prototype RshiftSignedLong_yzx ();
16027
16028  /** Returns the prototype invariant for RshiftSignedLong_yzx */
16029  public static @Prototype RshiftSignedLong_yzx get_proto() {
16030    return proto;
16031  }
16032
16033  /** instantiate an invariant on the specified slice */
16034  @Override
16035  protected RshiftSignedLong_yzx instantiate_dyn(@Prototype RshiftSignedLong_yzx this, PptSlice slice) {
16036    return new RshiftSignedLong_yzx (slice);
16037  }
16038
16039  private RshiftSignedLong_yzx (PptSlice slice) {
16040    super(slice);
16041  }
16042
16043  public @Prototype RshiftSignedLong_yzx () {
16044    super();
16045  }
16046
16047  private static String[] method_name = new String[] {"", " >> ", ""};
16048
16049  @Override
16050  public String[] get_method_name(@GuardSatisfied RshiftSignedLong_yzx this) {
16051    return method_name;
16052  }
16053
16054  private static int function_id = -1;
16055
16056  @Override
16057  public int get_function_id() {
16058    return function_id;
16059  }
16060
16061  @Override
16062  public void set_function_id(int function_id) {
16063    assert RshiftSignedLong_yzx.function_id == -1;
16064    RshiftSignedLong_yzx.function_id = function_id;
16065  }
16066
16067  private static int var_order = 5;
16068
16069  @Override
16070  public int get_var_order(@GuardSatisfied RshiftSignedLong_yzx this) {
16071    return var_order;
16072  }
16073
16074  @Pure
16075  @Override
16076  public boolean is_symmetric() {
16077
16078      return false;
16079  }
16080
16081  @Override
16082
16083  public long func(long z, long x) {
16084
16085      if ((x < arg2_bound[0]) || (x > arg2_bound[1])) {
16086        throw new ArithmeticException("arg2 (" + x + ") out of range "
16087                                       + arg2_bound[0] + ".." + arg2_bound[1]);
16088      }
16089
16090    return (z >> x);
16091  }
16092
16093  @Override
16094  public InvariantStatus check_modified(long x, long y,
16095                                      long z, int count) {
16096    return check_ordered(y, z, x, count);
16097  }
16098
16099  @Override
16100  public InvariantStatus add_modified(long x, long y,
16101                                      long z, int count) {
16102    if (Debug.logDetail()) {
16103      log("result=%s, arg1=%s, arg2=%s", y, z, x);
16104    }
16105    return add_ordered(y, z, x, count);
16106  }
16107
16108  @Pure
16109  @Override
16110  public boolean isRshiftSigned() {
16111    return true;
16112  }
16113
16114  /** Returns a list of non-instantiating suppressions for this invariant. */
16115  @Pure
16116  @Override
16117  public @Nullable NISuppressionSet get_ni_suppressions() {
16118    if (NIS.dkconfig_enabled && dkconfig_enabled) {
16119      return suppressions;
16120    } else {
16121      return null;
16122    }
16123  }
16124
16125  /** definition of this invariant (the suppressee) */
16126  private static NISuppressee suppressee = new NISuppressee(RshiftSignedLong_yzx.class, 3);
16127
16128  // suppressor definitions (used below)
16129  private static NISuppressor result_eq_arg1 =
16130      new NISuppressor(1, 2, IntEqual.class);
16131  private static NISuppressor result_eq_arg2 =
16132      new NISuppressor(1, 0, IntEqual.class);
16133  private static NISuppressor arg1_eq_arg2 =
16134      new NISuppressor(2, 0, IntEqual.class);
16135
16136  private static NISuppressor result_lt_arg1 =
16137      new NISuppressor(1, 2, IntLessThan.class);
16138  private static NISuppressor result_lt_arg2 =
16139      new NISuppressor(1, 0, IntLessThan.class);
16140  private static NISuppressor arg1_lt_arg2 =
16141      new NISuppressor(2, 0, IntLessThan.class);
16142  private static NISuppressor arg2_lt_arg1 =
16143      new NISuppressor(0, 2, IntLessThan.class);
16144
16145  private static NISuppressor result_le_arg1 =
16146      new NISuppressor(1, 2, IntLessEqual.class);
16147  private static NISuppressor result_le_arg2 =
16148      new NISuppressor(1, 0, IntLessEqual.class);
16149  private static NISuppressor arg1_le_arg2 =
16150      new NISuppressor(2, 0, IntLessEqual.class);
16151  private static NISuppressor arg2_le_arg1 =
16152      new NISuppressor(0, 2, IntLessEqual.class);
16153
16154  private static NISuppressor result_track0_arg1 =
16155      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
16156  private static NISuppressor result_track0_arg2 =
16157      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
16158  private static NISuppressor arg1_track0_arg2 =
16159      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
16160  private static NISuppressor arg1_track0_result =
16161      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
16162  private static NISuppressor arg2_track0_result =
16163      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
16164  private static NISuppressor arg2_track0_arg1 =
16165      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
16166
16167  private static NISuppressor result_eq_1 =
16168      new NISuppressor(1, RangeInt.EqualOne.class);
16169  private static NISuppressor arg1_eq_1 =
16170      new NISuppressor(2, RangeInt.EqualOne.class);
16171  private static NISuppressor arg2_eq_1 =
16172      new NISuppressor(0, RangeInt.EqualOne.class);
16173
16174  private static NISuppressor result_eq_0 =
16175      new NISuppressor(1, RangeInt.EqualZero.class);
16176  private static NISuppressor arg1_eq_0 =
16177      new NISuppressor(2, RangeInt.EqualZero.class);
16178  private static NISuppressor arg2_eq_0 =
16179      new NISuppressor(0, RangeInt.EqualZero.class);
16180
16181  private static NISuppressor result_ne_0 =
16182      new NISuppressor(1, NonZero.class);
16183  private static NISuppressor arg1_ne_0 =
16184      new NISuppressor(2, NonZero.class);
16185  private static NISuppressor arg2_ne_0 =
16186      new NISuppressor(0, NonZero.class);
16187
16188  private static NISuppressor result_ge_0 =
16189      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
16190  private static NISuppressor arg1_ge_0 =
16191      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
16192  private static NISuppressor arg2_ge_0 =
16193      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
16194
16195  private static NISuppressor result_ge_64 =
16196      new NISuppressor(1, RangeInt.GreaterEqual64.class);
16197  private static NISuppressor arg1_ge_64 =
16198      new NISuppressor(2, RangeInt.GreaterEqual64.class);
16199  private static NISuppressor arg2_ge_64 =
16200      new NISuppressor(0, RangeInt.GreaterEqual64.class);
16201
16202  private static NISuppressor result_boolean =
16203      new NISuppressor(1, RangeInt.BooleanVal.class);
16204  private static NISuppressor arg1_boolean =
16205      new NISuppressor(2, RangeInt.BooleanVal.class);
16206  private static NISuppressor arg2_boolean =
16207      new NISuppressor(0, RangeInt.BooleanVal.class);
16208
16209  private static NISuppressor result_even =
16210      new NISuppressor(1, RangeInt.Even.class);
16211  private static NISuppressor arg1_even =
16212      new NISuppressor(2, RangeInt.Even.class);
16213  private static NISuppressor arg2_even =
16214      new NISuppressor(0, RangeInt.Even.class);
16215
16216  private static NISuppressor result_power2 =
16217      new NISuppressor(1, RangeInt.PowerOfTwo.class);
16218  private static NISuppressor arg1_power2 =
16219      new NISuppressor(2, RangeInt.PowerOfTwo.class);
16220  private static NISuppressor arg2_power2 =
16221      new NISuppressor(0, RangeInt.PowerOfTwo.class);
16222
16223  private static NISuppressor result_and0_arg1 =
16224      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
16225  private static NISuppressor result_and0_arg2 =
16226      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
16227  private static NISuppressor arg1_and0_arg2 =
16228      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
16229
16230  // The arguments to bitwise subset are backwards from what one
16231  // might expect.  The second argument is a subset of the first
16232  // argument
16233  private static NISuppressor arg1_bw_subset_arg2 =
16234      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
16235  private static NISuppressor arg2_bw_subset_arg1 =
16236      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
16237
16238  private static NISuppressor result_shift0_arg1 =
16239      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
16240  private static NISuppressor result_shift0_arg2 =
16241      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
16242  private static NISuppressor arg1_shift0_arg2 =
16243      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
16244
16245  private static NISuppressor arg2_divides_arg1 =
16246      new NISuppressor(2, 0, NumericInt.Divides.class);
16247  private static NISuppressor arg1_divides_arg2 =
16248      new NISuppressor(0, 2, NumericInt.Divides.class);
16249
16250  private static NISuppressor arg2_valid_shift =
16251      new NISuppressor(0, RangeInt.Bound0_63.class);
16252
16253    private static NISuppressionSet suppressions =
16254        new NISuppressionSet(
16255          new NISuppression[] {
16256
16257            // (r == z) && (x == 0) ==> r = z >>> x
16258            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
16259
16260            // (r == 0) && (z == 0) && (0 <= x <= 63)   ==> r = z >>> x
16261            // new NISuppression (result_eq_0, arg1_eq_0, arg2_valid_shift, suppressee),
16262
16263            // (r == 0) && ((z >> x) == 0)
16264            new NISuppression(result_eq_0, arg1_shift0_arg2, suppressee),
16265
16266            // (r == 0) && (x >= z) && (z >= 0) && (x valid shift)
16267            // This suppression really ought to have 2**x >= z, but we
16268            // don't have that invariant.  This still might catch a lot of these.
16269            // new NISuppression (result_eq_0, arg1_le_arg2, arg1_ge_0,
16270            //                   arg2_valid_shift, suppressee),
16271          });
16272
16273  // Create a suppression factory for functionBinary
16274
16275}
16276
16277/**
16278 * Represents the invariant {@code z = RshiftSigned(y, x)} over three long
16279 * scalars. 
16280 */
16281public static class RshiftSignedLong_zyx extends FunctionBinary {
16282  // We are Serializable, so we specify a version to allow changes to
16283  // method signatures without breaking serialization.  If you add or
16284  // remove fields, you should change this number to the current date.
16285  static final long serialVersionUID = 20031030L;
16286
16287    // x must be between arg2_bound[0] and arg2_bound[1] inclusive
16288    static int[] arg2_bound = {0, 63};
16289
16290  private static @Prototype RshiftSignedLong_zyx proto = new @Prototype RshiftSignedLong_zyx ();
16291
16292  /** Returns the prototype invariant for RshiftSignedLong_zyx */
16293  public static @Prototype RshiftSignedLong_zyx get_proto() {
16294    return proto;
16295  }
16296
16297  /** instantiate an invariant on the specified slice */
16298  @Override
16299  protected RshiftSignedLong_zyx instantiate_dyn(@Prototype RshiftSignedLong_zyx this, PptSlice slice) {
16300    return new RshiftSignedLong_zyx (slice);
16301  }
16302
16303  private RshiftSignedLong_zyx (PptSlice slice) {
16304    super(slice);
16305  }
16306
16307  public @Prototype RshiftSignedLong_zyx () {
16308    super();
16309  }
16310
16311  private static String[] method_name = new String[] {"", " >> ", ""};
16312
16313  @Override
16314  public String[] get_method_name(@GuardSatisfied RshiftSignedLong_zyx this) {
16315    return method_name;
16316  }
16317
16318  private static int function_id = -1;
16319
16320  @Override
16321  public int get_function_id() {
16322    return function_id;
16323  }
16324
16325  @Override
16326  public void set_function_id(int function_id) {
16327    assert RshiftSignedLong_zyx.function_id == -1;
16328    RshiftSignedLong_zyx.function_id = function_id;
16329  }
16330
16331  private static int var_order = 6;
16332
16333  @Override
16334  public int get_var_order(@GuardSatisfied RshiftSignedLong_zyx this) {
16335    return var_order;
16336  }
16337
16338  @Pure
16339  @Override
16340  public boolean is_symmetric() {
16341
16342      return false;
16343  }
16344
16345  @Override
16346
16347  public long func(long y, long x) {
16348
16349      if ((x < arg2_bound[0]) || (x > arg2_bound[1])) {
16350        throw new ArithmeticException("arg2 (" + x + ") out of range "
16351                                       + arg2_bound[0] + ".." + arg2_bound[1]);
16352      }
16353
16354    return (y >> x);
16355  }
16356
16357  @Override
16358  public InvariantStatus check_modified(long x, long y,
16359                                      long z, int count) {
16360    return check_ordered(z, y, x, count);
16361  }
16362
16363  @Override
16364  public InvariantStatus add_modified(long x, long y,
16365                                      long z, int count) {
16366    if (Debug.logDetail()) {
16367      log("result=%s, arg1=%s, arg2=%s", z, y, x);
16368    }
16369    return add_ordered(z, y, x, count);
16370  }
16371
16372  @Pure
16373  @Override
16374  public boolean isRshiftSigned() {
16375    return true;
16376  }
16377
16378  /** Returns a list of non-instantiating suppressions for this invariant. */
16379  @Pure
16380  @Override
16381  public @Nullable NISuppressionSet get_ni_suppressions() {
16382    if (NIS.dkconfig_enabled && dkconfig_enabled) {
16383      return suppressions;
16384    } else {
16385      return null;
16386    }
16387  }
16388
16389  /** definition of this invariant (the suppressee) */
16390  private static NISuppressee suppressee = new NISuppressee(RshiftSignedLong_zyx.class, 3);
16391
16392  // suppressor definitions (used below)
16393  private static NISuppressor result_eq_arg1 =
16394      new NISuppressor(2, 1, IntEqual.class);
16395  private static NISuppressor result_eq_arg2 =
16396      new NISuppressor(2, 0, IntEqual.class);
16397  private static NISuppressor arg1_eq_arg2 =
16398      new NISuppressor(1, 0, IntEqual.class);
16399
16400  private static NISuppressor result_lt_arg1 =
16401      new NISuppressor(2, 1, IntLessThan.class);
16402  private static NISuppressor result_lt_arg2 =
16403      new NISuppressor(2, 0, IntLessThan.class);
16404  private static NISuppressor arg1_lt_arg2 =
16405      new NISuppressor(1, 0, IntLessThan.class);
16406  private static NISuppressor arg2_lt_arg1 =
16407      new NISuppressor(0, 1, IntLessThan.class);
16408
16409  private static NISuppressor result_le_arg1 =
16410      new NISuppressor(2, 1, IntLessEqual.class);
16411  private static NISuppressor result_le_arg2 =
16412      new NISuppressor(2, 0, IntLessEqual.class);
16413  private static NISuppressor arg1_le_arg2 =
16414      new NISuppressor(1, 0, IntLessEqual.class);
16415  private static NISuppressor arg2_le_arg1 =
16416      new NISuppressor(0, 1, IntLessEqual.class);
16417
16418  private static NISuppressor result_track0_arg1 =
16419      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
16420  private static NISuppressor result_track0_arg2 =
16421      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
16422  private static NISuppressor arg1_track0_arg2 =
16423      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
16424  private static NISuppressor arg1_track0_result =
16425      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
16426  private static NISuppressor arg2_track0_result =
16427      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
16428  private static NISuppressor arg2_track0_arg1 =
16429      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
16430
16431  private static NISuppressor result_eq_1 =
16432      new NISuppressor(2, RangeInt.EqualOne.class);
16433  private static NISuppressor arg1_eq_1 =
16434      new NISuppressor(1, RangeInt.EqualOne.class);
16435  private static NISuppressor arg2_eq_1 =
16436      new NISuppressor(0, RangeInt.EqualOne.class);
16437
16438  private static NISuppressor result_eq_0 =
16439      new NISuppressor(2, RangeInt.EqualZero.class);
16440  private static NISuppressor arg1_eq_0 =
16441      new NISuppressor(1, RangeInt.EqualZero.class);
16442  private static NISuppressor arg2_eq_0 =
16443      new NISuppressor(0, RangeInt.EqualZero.class);
16444
16445  private static NISuppressor result_ne_0 =
16446      new NISuppressor(2, NonZero.class);
16447  private static NISuppressor arg1_ne_0 =
16448      new NISuppressor(1, NonZero.class);
16449  private static NISuppressor arg2_ne_0 =
16450      new NISuppressor(0, NonZero.class);
16451
16452  private static NISuppressor result_ge_0 =
16453      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
16454  private static NISuppressor arg1_ge_0 =
16455      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
16456  private static NISuppressor arg2_ge_0 =
16457      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
16458
16459  private static NISuppressor result_ge_64 =
16460      new NISuppressor(2, RangeInt.GreaterEqual64.class);
16461  private static NISuppressor arg1_ge_64 =
16462      new NISuppressor(1, RangeInt.GreaterEqual64.class);
16463  private static NISuppressor arg2_ge_64 =
16464      new NISuppressor(0, RangeInt.GreaterEqual64.class);
16465
16466  private static NISuppressor result_boolean =
16467      new NISuppressor(2, RangeInt.BooleanVal.class);
16468  private static NISuppressor arg1_boolean =
16469      new NISuppressor(1, RangeInt.BooleanVal.class);
16470  private static NISuppressor arg2_boolean =
16471      new NISuppressor(0, RangeInt.BooleanVal.class);
16472
16473  private static NISuppressor result_even =
16474      new NISuppressor(2, RangeInt.Even.class);
16475  private static NISuppressor arg1_even =
16476      new NISuppressor(1, RangeInt.Even.class);
16477  private static NISuppressor arg2_even =
16478      new NISuppressor(0, RangeInt.Even.class);
16479
16480  private static NISuppressor result_power2 =
16481      new NISuppressor(2, RangeInt.PowerOfTwo.class);
16482  private static NISuppressor arg1_power2 =
16483      new NISuppressor(1, RangeInt.PowerOfTwo.class);
16484  private static NISuppressor arg2_power2 =
16485      new NISuppressor(0, RangeInt.PowerOfTwo.class);
16486
16487  private static NISuppressor result_and0_arg1 =
16488      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
16489  private static NISuppressor result_and0_arg2 =
16490      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
16491  private static NISuppressor arg1_and0_arg2 =
16492      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
16493
16494  // The arguments to bitwise subset are backwards from what one
16495  // might expect.  The second argument is a subset of the first
16496  // argument
16497  private static NISuppressor arg1_bw_subset_arg2 =
16498      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
16499  private static NISuppressor arg2_bw_subset_arg1 =
16500      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
16501
16502  private static NISuppressor result_shift0_arg1 =
16503      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
16504  private static NISuppressor result_shift0_arg2 =
16505      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
16506  private static NISuppressor arg1_shift0_arg2 =
16507      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
16508
16509  private static NISuppressor arg2_divides_arg1 =
16510      new NISuppressor(1, 0, NumericInt.Divides.class);
16511  private static NISuppressor arg1_divides_arg2 =
16512      new NISuppressor(0, 1, NumericInt.Divides.class);
16513
16514  private static NISuppressor arg2_valid_shift =
16515      new NISuppressor(0, RangeInt.Bound0_63.class);
16516
16517    private static NISuppressionSet suppressions =
16518        new NISuppressionSet(
16519          new NISuppression[] {
16520
16521            // (r == y) && (x == 0) ==> r = y >>> x
16522            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
16523
16524            // (r == 0) && (y == 0) && (0 <= x <= 63)   ==> r = y >>> x
16525            // new NISuppression (result_eq_0, arg1_eq_0, arg2_valid_shift, suppressee),
16526
16527            // (r == 0) && ((y >> x) == 0)
16528            new NISuppression(result_eq_0, arg1_shift0_arg2, suppressee),
16529
16530            // (r == 0) && (x >= y) && (y >= 0) && (x valid shift)
16531            // This suppression really ought to have 2**x >= y, but we
16532            // don't have that invariant.  This still might catch a lot of these.
16533            // new NISuppression (result_eq_0, arg1_le_arg2, arg1_ge_0,
16534            //                   arg2_valid_shift, suppressee),
16535          });
16536
16537  // Create a suppression factory for functionBinary
16538
16539}
16540
16541  // default is that it is not this function, overriden in the subclass
16542  @Pure
16543  public boolean isRshiftUnsigned() {
16544    return false;
16545  }
16546
16547/**
16548 * Represents the invariant {@code x = RshiftUnsigned(y, z)} over three long
16549 * scalars. 
16550 */
16551public static class RshiftUnsignedLong_xyz extends FunctionBinary {
16552  // We are Serializable, so we specify a version to allow changes to
16553  // method signatures without breaking serialization.  If you add or
16554  // remove fields, you should change this number to the current date.
16555  static final long serialVersionUID = 20031030L;
16556
16557    // z must be between arg2_bound[0] and arg2_bound[1] inclusive
16558    static int[] arg2_bound = {0, 63};
16559
16560  private static @Prototype RshiftUnsignedLong_xyz proto = new @Prototype RshiftUnsignedLong_xyz ();
16561
16562  /** Returns the prototype invariant for RshiftUnsignedLong_xyz */
16563  public static @Prototype RshiftUnsignedLong_xyz get_proto() {
16564    return proto;
16565  }
16566
16567  /** instantiate an invariant on the specified slice */
16568  @Override
16569  protected RshiftUnsignedLong_xyz instantiate_dyn(@Prototype RshiftUnsignedLong_xyz this, PptSlice slice) {
16570    return new RshiftUnsignedLong_xyz (slice);
16571  }
16572
16573  private RshiftUnsignedLong_xyz (PptSlice slice) {
16574    super(slice);
16575  }
16576
16577  public @Prototype RshiftUnsignedLong_xyz () {
16578    super();
16579  }
16580
16581  private static String[] method_name = new String[] {"", " >>> ", ""};
16582
16583  @Override
16584  public String[] get_method_name(@GuardSatisfied RshiftUnsignedLong_xyz this) {
16585    return method_name;
16586  }
16587
16588  private static int function_id = -1;
16589
16590  @Override
16591  public int get_function_id() {
16592    return function_id;
16593  }
16594
16595  @Override
16596  public void set_function_id(int function_id) {
16597    assert RshiftUnsignedLong_xyz.function_id == -1;
16598    RshiftUnsignedLong_xyz.function_id = function_id;
16599  }
16600
16601  private static int var_order = 1;
16602
16603  @Override
16604  public int get_var_order(@GuardSatisfied RshiftUnsignedLong_xyz this) {
16605    return var_order;
16606  }
16607
16608  @Pure
16609  @Override
16610  public boolean is_symmetric() {
16611
16612      return false;
16613  }
16614
16615  @Override
16616
16617  @SuppressWarnings("signedness:shift.unsigned") // RshiftUnsigned treats y as unsigned, though we do not know how the program under test treats it
16618
16619  public long func(long y, long z) {
16620
16621      if ((z < arg2_bound[0]) || (z > arg2_bound[1])) {
16622        throw new ArithmeticException("arg2 (" + z + ") out of range "
16623                                       + arg2_bound[0] + ".." + arg2_bound[1]);
16624      }
16625
16626    return (y >>> z);
16627  }
16628
16629  @Override
16630  public InvariantStatus check_modified(long x, long y,
16631                                      long z, int count) {
16632    return check_ordered(x, y, z, count);
16633  }
16634
16635  @Override
16636  public InvariantStatus add_modified(long x, long y,
16637                                      long z, int count) {
16638    if (Debug.logDetail()) {
16639      log("result=%s, arg1=%s, arg2=%s", x, y, z);
16640    }
16641    return add_ordered(x, y, z, count);
16642  }
16643
16644  @Pure
16645  @Override
16646  public boolean isRshiftUnsigned() {
16647    return true;
16648  }
16649
16650  /** Returns a list of non-instantiating suppressions for this invariant. */
16651  @Pure
16652  @Override
16653  public @Nullable NISuppressionSet get_ni_suppressions() {
16654    if (NIS.dkconfig_enabled && dkconfig_enabled) {
16655      return suppressions;
16656    } else {
16657      return null;
16658    }
16659  }
16660
16661  /** definition of this invariant (the suppressee) */
16662  private static NISuppressee suppressee = new NISuppressee(RshiftUnsignedLong_xyz.class, 3);
16663
16664  // suppressor definitions (used below)
16665  private static NISuppressor result_eq_arg1 =
16666      new NISuppressor(0, 1, IntEqual.class);
16667  private static NISuppressor result_eq_arg2 =
16668      new NISuppressor(0, 2, IntEqual.class);
16669  private static NISuppressor arg1_eq_arg2 =
16670      new NISuppressor(1, 2, IntEqual.class);
16671
16672  private static NISuppressor result_lt_arg1 =
16673      new NISuppressor(0, 1, IntLessThan.class);
16674  private static NISuppressor result_lt_arg2 =
16675      new NISuppressor(0, 2, IntLessThan.class);
16676  private static NISuppressor arg1_lt_arg2 =
16677      new NISuppressor(1, 2, IntLessThan.class);
16678  private static NISuppressor arg2_lt_arg1 =
16679      new NISuppressor(2, 1, IntLessThan.class);
16680
16681  private static NISuppressor result_le_arg1 =
16682      new NISuppressor(0, 1, IntLessEqual.class);
16683  private static NISuppressor result_le_arg2 =
16684      new NISuppressor(0, 2, IntLessEqual.class);
16685  private static NISuppressor arg1_le_arg2 =
16686      new NISuppressor(1, 2, IntLessEqual.class);
16687  private static NISuppressor arg2_le_arg1 =
16688      new NISuppressor(2, 1, IntLessEqual.class);
16689
16690  private static NISuppressor result_track0_arg1 =
16691      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
16692  private static NISuppressor result_track0_arg2 =
16693      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
16694  private static NISuppressor arg1_track0_arg2 =
16695      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
16696  private static NISuppressor arg1_track0_result =
16697      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
16698  private static NISuppressor arg2_track0_result =
16699      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
16700  private static NISuppressor arg2_track0_arg1 =
16701      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
16702
16703  private static NISuppressor result_eq_1 =
16704      new NISuppressor(0, RangeInt.EqualOne.class);
16705  private static NISuppressor arg1_eq_1 =
16706      new NISuppressor(1, RangeInt.EqualOne.class);
16707  private static NISuppressor arg2_eq_1 =
16708      new NISuppressor(2, RangeInt.EqualOne.class);
16709
16710  private static NISuppressor result_eq_0 =
16711      new NISuppressor(0, RangeInt.EqualZero.class);
16712  private static NISuppressor arg1_eq_0 =
16713      new NISuppressor(1, RangeInt.EqualZero.class);
16714  private static NISuppressor arg2_eq_0 =
16715      new NISuppressor(2, RangeInt.EqualZero.class);
16716
16717  private static NISuppressor result_ne_0 =
16718      new NISuppressor(0, NonZero.class);
16719  private static NISuppressor arg1_ne_0 =
16720      new NISuppressor(1, NonZero.class);
16721  private static NISuppressor arg2_ne_0 =
16722      new NISuppressor(2, NonZero.class);
16723
16724  private static NISuppressor result_ge_0 =
16725      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
16726  private static NISuppressor arg1_ge_0 =
16727      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
16728  private static NISuppressor arg2_ge_0 =
16729      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
16730
16731  private static NISuppressor result_ge_64 =
16732      new NISuppressor(0, RangeInt.GreaterEqual64.class);
16733  private static NISuppressor arg1_ge_64 =
16734      new NISuppressor(1, RangeInt.GreaterEqual64.class);
16735  private static NISuppressor arg2_ge_64 =
16736      new NISuppressor(2, RangeInt.GreaterEqual64.class);
16737
16738  private static NISuppressor result_boolean =
16739      new NISuppressor(0, RangeInt.BooleanVal.class);
16740  private static NISuppressor arg1_boolean =
16741      new NISuppressor(1, RangeInt.BooleanVal.class);
16742  private static NISuppressor arg2_boolean =
16743      new NISuppressor(2, RangeInt.BooleanVal.class);
16744
16745  private static NISuppressor result_even =
16746      new NISuppressor(0, RangeInt.Even.class);
16747  private static NISuppressor arg1_even =
16748      new NISuppressor(1, RangeInt.Even.class);
16749  private static NISuppressor arg2_even =
16750      new NISuppressor(2, RangeInt.Even.class);
16751
16752  private static NISuppressor result_power2 =
16753      new NISuppressor(0, RangeInt.PowerOfTwo.class);
16754  private static NISuppressor arg1_power2 =
16755      new NISuppressor(1, RangeInt.PowerOfTwo.class);
16756  private static NISuppressor arg2_power2 =
16757      new NISuppressor(2, RangeInt.PowerOfTwo.class);
16758
16759  private static NISuppressor result_and0_arg1 =
16760      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
16761  private static NISuppressor result_and0_arg2 =
16762      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
16763  private static NISuppressor arg1_and0_arg2 =
16764      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
16765
16766  // The arguments to bitwise subset are backwards from what one
16767  // might expect.  The second argument is a subset of the first
16768  // argument
16769  private static NISuppressor arg1_bw_subset_arg2 =
16770      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
16771  private static NISuppressor arg2_bw_subset_arg1 =
16772      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
16773
16774  private static NISuppressor result_shift0_arg1 =
16775      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
16776  private static NISuppressor result_shift0_arg2 =
16777      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
16778  private static NISuppressor arg1_shift0_arg2 =
16779      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
16780
16781  private static NISuppressor arg2_divides_arg1 =
16782      new NISuppressor(1, 2, NumericInt.Divides.class);
16783  private static NISuppressor arg1_divides_arg2 =
16784      new NISuppressor(2, 1, NumericInt.Divides.class);
16785
16786  private static NISuppressor arg2_valid_shift =
16787      new NISuppressor(2, RangeInt.Bound0_63.class);
16788
16789    private static NISuppressionSet suppressions =
16790        new NISuppressionSet(
16791          new NISuppression[] {
16792
16793            // (r == y) && (z == 0) ==> r = y >>> z
16794            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
16795
16796            // (r == 0) && (y == 0) && (z valid shift) ==> r = y >>> z
16797            // new NISuppression (result_eq_0, arg1_eq_0, arg2_valid_shift, suppressee),
16798
16799            // (r == 0) && ((y >> z) == 0)
16800            new NISuppression(result_eq_0, arg1_shift0_arg2, suppressee),
16801
16802            // (r == 0) && (z >= y) && (y >= 0) && (z valid shift)
16803            // This suppression really ought to have 2**z >= y, but we
16804            // don't have that suppression.  This still might catch a lot of these.
16805            // new NISuppression (result_eq_0, arg1_le_arg2, arg1_ge_0,
16806            //                   arg2_valid_shift, suppressee),
16807          });
16808
16809  // Create a suppression factory for functionBinary
16810
16811}
16812
16813/**
16814 * Represents the invariant {@code y = RshiftUnsigned(x, z)} over three long
16815 * scalars. 
16816 */
16817public static class RshiftUnsignedLong_yxz extends FunctionBinary {
16818  // We are Serializable, so we specify a version to allow changes to
16819  // method signatures without breaking serialization.  If you add or
16820  // remove fields, you should change this number to the current date.
16821  static final long serialVersionUID = 20031030L;
16822
16823    // z must be between arg2_bound[0] and arg2_bound[1] inclusive
16824    static int[] arg2_bound = {0, 63};
16825
16826  private static @Prototype RshiftUnsignedLong_yxz proto = new @Prototype RshiftUnsignedLong_yxz ();
16827
16828  /** Returns the prototype invariant for RshiftUnsignedLong_yxz */
16829  public static @Prototype RshiftUnsignedLong_yxz get_proto() {
16830    return proto;
16831  }
16832
16833  /** instantiate an invariant on the specified slice */
16834  @Override
16835  protected RshiftUnsignedLong_yxz instantiate_dyn(@Prototype RshiftUnsignedLong_yxz this, PptSlice slice) {
16836    return new RshiftUnsignedLong_yxz (slice);
16837  }
16838
16839  private RshiftUnsignedLong_yxz (PptSlice slice) {
16840    super(slice);
16841  }
16842
16843  public @Prototype RshiftUnsignedLong_yxz () {
16844    super();
16845  }
16846
16847  private static String[] method_name = new String[] {"", " >>> ", ""};
16848
16849  @Override
16850  public String[] get_method_name(@GuardSatisfied RshiftUnsignedLong_yxz this) {
16851    return method_name;
16852  }
16853
16854  private static int function_id = -1;
16855
16856  @Override
16857  public int get_function_id() {
16858    return function_id;
16859  }
16860
16861  @Override
16862  public void set_function_id(int function_id) {
16863    assert RshiftUnsignedLong_yxz.function_id == -1;
16864    RshiftUnsignedLong_yxz.function_id = function_id;
16865  }
16866
16867  private static int var_order = 2;
16868
16869  @Override
16870  public int get_var_order(@GuardSatisfied RshiftUnsignedLong_yxz this) {
16871    return var_order;
16872  }
16873
16874  @Pure
16875  @Override
16876  public boolean is_symmetric() {
16877
16878      return false;
16879  }
16880
16881  @Override
16882
16883  @SuppressWarnings("signedness:shift.unsigned") // RshiftUnsigned treats x as unsigned, though we do not know how the program under test treats it
16884
16885  public long func(long x, long z) {
16886
16887      if ((z < arg2_bound[0]) || (z > arg2_bound[1])) {
16888        throw new ArithmeticException("arg2 (" + z + ") out of range "
16889                                       + arg2_bound[0] + ".." + arg2_bound[1]);
16890      }
16891
16892    return (x >>> z);
16893  }
16894
16895  @Override
16896  public InvariantStatus check_modified(long x, long y,
16897                                      long z, int count) {
16898    return check_ordered(y, x, z, count);
16899  }
16900
16901  @Override
16902  public InvariantStatus add_modified(long x, long y,
16903                                      long z, int count) {
16904    if (Debug.logDetail()) {
16905      log("result=%s, arg1=%s, arg2=%s", y, x, z);
16906    }
16907    return add_ordered(y, x, z, count);
16908  }
16909
16910  @Pure
16911  @Override
16912  public boolean isRshiftUnsigned() {
16913    return true;
16914  }
16915
16916  /** Returns a list of non-instantiating suppressions for this invariant. */
16917  @Pure
16918  @Override
16919  public @Nullable NISuppressionSet get_ni_suppressions() {
16920    if (NIS.dkconfig_enabled && dkconfig_enabled) {
16921      return suppressions;
16922    } else {
16923      return null;
16924    }
16925  }
16926
16927  /** definition of this invariant (the suppressee) */
16928  private static NISuppressee suppressee = new NISuppressee(RshiftUnsignedLong_yxz.class, 3);
16929
16930  // suppressor definitions (used below)
16931  private static NISuppressor result_eq_arg1 =
16932      new NISuppressor(1, 0, IntEqual.class);
16933  private static NISuppressor result_eq_arg2 =
16934      new NISuppressor(1, 2, IntEqual.class);
16935  private static NISuppressor arg1_eq_arg2 =
16936      new NISuppressor(0, 2, IntEqual.class);
16937
16938  private static NISuppressor result_lt_arg1 =
16939      new NISuppressor(1, 0, IntLessThan.class);
16940  private static NISuppressor result_lt_arg2 =
16941      new NISuppressor(1, 2, IntLessThan.class);
16942  private static NISuppressor arg1_lt_arg2 =
16943      new NISuppressor(0, 2, IntLessThan.class);
16944  private static NISuppressor arg2_lt_arg1 =
16945      new NISuppressor(2, 0, IntLessThan.class);
16946
16947  private static NISuppressor result_le_arg1 =
16948      new NISuppressor(1, 0, IntLessEqual.class);
16949  private static NISuppressor result_le_arg2 =
16950      new NISuppressor(1, 2, IntLessEqual.class);
16951  private static NISuppressor arg1_le_arg2 =
16952      new NISuppressor(0, 2, IntLessEqual.class);
16953  private static NISuppressor arg2_le_arg1 =
16954      new NISuppressor(2, 0, IntLessEqual.class);
16955
16956  private static NISuppressor result_track0_arg1 =
16957      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
16958  private static NISuppressor result_track0_arg2 =
16959      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
16960  private static NISuppressor arg1_track0_arg2 =
16961      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
16962  private static NISuppressor arg1_track0_result =
16963      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
16964  private static NISuppressor arg2_track0_result =
16965      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
16966  private static NISuppressor arg2_track0_arg1 =
16967      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
16968
16969  private static NISuppressor result_eq_1 =
16970      new NISuppressor(1, RangeInt.EqualOne.class);
16971  private static NISuppressor arg1_eq_1 =
16972      new NISuppressor(0, RangeInt.EqualOne.class);
16973  private static NISuppressor arg2_eq_1 =
16974      new NISuppressor(2, RangeInt.EqualOne.class);
16975
16976  private static NISuppressor result_eq_0 =
16977      new NISuppressor(1, RangeInt.EqualZero.class);
16978  private static NISuppressor arg1_eq_0 =
16979      new NISuppressor(0, RangeInt.EqualZero.class);
16980  private static NISuppressor arg2_eq_0 =
16981      new NISuppressor(2, RangeInt.EqualZero.class);
16982
16983  private static NISuppressor result_ne_0 =
16984      new NISuppressor(1, NonZero.class);
16985  private static NISuppressor arg1_ne_0 =
16986      new NISuppressor(0, NonZero.class);
16987  private static NISuppressor arg2_ne_0 =
16988      new NISuppressor(2, NonZero.class);
16989
16990  private static NISuppressor result_ge_0 =
16991      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
16992  private static NISuppressor arg1_ge_0 =
16993      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
16994  private static NISuppressor arg2_ge_0 =
16995      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
16996
16997  private static NISuppressor result_ge_64 =
16998      new NISuppressor(1, RangeInt.GreaterEqual64.class);
16999  private static NISuppressor arg1_ge_64 =
17000      new NISuppressor(0, RangeInt.GreaterEqual64.class);
17001  private static NISuppressor arg2_ge_64 =
17002      new NISuppressor(2, RangeInt.GreaterEqual64.class);
17003
17004  private static NISuppressor result_boolean =
17005      new NISuppressor(1, RangeInt.BooleanVal.class);
17006  private static NISuppressor arg1_boolean =
17007      new NISuppressor(0, RangeInt.BooleanVal.class);
17008  private static NISuppressor arg2_boolean =
17009      new NISuppressor(2, RangeInt.BooleanVal.class);
17010
17011  private static NISuppressor result_even =
17012      new NISuppressor(1, RangeInt.Even.class);
17013  private static NISuppressor arg1_even =
17014      new NISuppressor(0, RangeInt.Even.class);
17015  private static NISuppressor arg2_even =
17016      new NISuppressor(2, RangeInt.Even.class);
17017
17018  private static NISuppressor result_power2 =
17019      new NISuppressor(1, RangeInt.PowerOfTwo.class);
17020  private static NISuppressor arg1_power2 =
17021      new NISuppressor(0, RangeInt.PowerOfTwo.class);
17022  private static NISuppressor arg2_power2 =
17023      new NISuppressor(2, RangeInt.PowerOfTwo.class);
17024
17025  private static NISuppressor result_and0_arg1 =
17026      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
17027  private static NISuppressor result_and0_arg2 =
17028      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
17029  private static NISuppressor arg1_and0_arg2 =
17030      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
17031
17032  // The arguments to bitwise subset are backwards from what one
17033  // might expect.  The second argument is a subset of the first
17034  // argument
17035  private static NISuppressor arg1_bw_subset_arg2 =
17036      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
17037  private static NISuppressor arg2_bw_subset_arg1 =
17038      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
17039
17040  private static NISuppressor result_shift0_arg1 =
17041      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
17042  private static NISuppressor result_shift0_arg2 =
17043      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
17044  private static NISuppressor arg1_shift0_arg2 =
17045      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
17046
17047  private static NISuppressor arg2_divides_arg1 =
17048      new NISuppressor(0, 2, NumericInt.Divides.class);
17049  private static NISuppressor arg1_divides_arg2 =
17050      new NISuppressor(2, 0, NumericInt.Divides.class);
17051
17052  private static NISuppressor arg2_valid_shift =
17053      new NISuppressor(2, RangeInt.Bound0_63.class);
17054
17055    private static NISuppressionSet suppressions =
17056        new NISuppressionSet(
17057          new NISuppression[] {
17058
17059            // (r == x) && (z == 0) ==> r = x >>> z
17060            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
17061
17062            // (r == 0) && (x == 0) && (z valid shift) ==> r = x >>> z
17063            // new NISuppression (result_eq_0, arg1_eq_0, arg2_valid_shift, suppressee),
17064
17065            // (r == 0) && ((x >> z) == 0)
17066            new NISuppression(result_eq_0, arg1_shift0_arg2, suppressee),
17067
17068            // (r == 0) && (z >= x) && (x >= 0) && (z valid shift)
17069            // This suppression really ought to have 2**z >= x, but we
17070            // don't have that suppression.  This still might catch a lot of these.
17071            // new NISuppression (result_eq_0, arg1_le_arg2, arg1_ge_0,
17072            //                   arg2_valid_shift, suppressee),
17073          });
17074
17075  // Create a suppression factory for functionBinary
17076
17077}
17078
17079/**
17080 * Represents the invariant {@code z = RshiftUnsigned(x, y)} over three long
17081 * scalars. 
17082 */
17083public static class RshiftUnsignedLong_zxy extends FunctionBinary {
17084  // We are Serializable, so we specify a version to allow changes to
17085  // method signatures without breaking serialization.  If you add or
17086  // remove fields, you should change this number to the current date.
17087  static final long serialVersionUID = 20031030L;
17088
17089    // y must be between arg2_bound[0] and arg2_bound[1] inclusive
17090    static int[] arg2_bound = {0, 63};
17091
17092  private static @Prototype RshiftUnsignedLong_zxy proto = new @Prototype RshiftUnsignedLong_zxy ();
17093
17094  /** Returns the prototype invariant for RshiftUnsignedLong_zxy */
17095  public static @Prototype RshiftUnsignedLong_zxy get_proto() {
17096    return proto;
17097  }
17098
17099  /** instantiate an invariant on the specified slice */
17100  @Override
17101  protected RshiftUnsignedLong_zxy instantiate_dyn(@Prototype RshiftUnsignedLong_zxy this, PptSlice slice) {
17102    return new RshiftUnsignedLong_zxy (slice);
17103  }
17104
17105  private RshiftUnsignedLong_zxy (PptSlice slice) {
17106    super(slice);
17107  }
17108
17109  public @Prototype RshiftUnsignedLong_zxy () {
17110    super();
17111  }
17112
17113  private static String[] method_name = new String[] {"", " >>> ", ""};
17114
17115  @Override
17116  public String[] get_method_name(@GuardSatisfied RshiftUnsignedLong_zxy this) {
17117    return method_name;
17118  }
17119
17120  private static int function_id = -1;
17121
17122  @Override
17123  public int get_function_id() {
17124    return function_id;
17125  }
17126
17127  @Override
17128  public void set_function_id(int function_id) {
17129    assert RshiftUnsignedLong_zxy.function_id == -1;
17130    RshiftUnsignedLong_zxy.function_id = function_id;
17131  }
17132
17133  private static int var_order = 3;
17134
17135  @Override
17136  public int get_var_order(@GuardSatisfied RshiftUnsignedLong_zxy this) {
17137    return var_order;
17138  }
17139
17140  @Pure
17141  @Override
17142  public boolean is_symmetric() {
17143
17144      return false;
17145  }
17146
17147  @Override
17148
17149  @SuppressWarnings("signedness:shift.unsigned") // RshiftUnsigned treats x as unsigned, though we do not know how the program under test treats it
17150
17151  public long func(long x, long y) {
17152
17153      if ((y < arg2_bound[0]) || (y > arg2_bound[1])) {
17154        throw new ArithmeticException("arg2 (" + y + ") out of range "
17155                                       + arg2_bound[0] + ".." + arg2_bound[1]);
17156      }
17157
17158    return (x >>> y);
17159  }
17160
17161  @Override
17162  public InvariantStatus check_modified(long x, long y,
17163                                      long z, int count) {
17164    return check_ordered(z, x, y, count);
17165  }
17166
17167  @Override
17168  public InvariantStatus add_modified(long x, long y,
17169                                      long z, int count) {
17170    if (Debug.logDetail()) {
17171      log("result=%s, arg1=%s, arg2=%s", z, x, y);
17172    }
17173    return add_ordered(z, x, y, count);
17174  }
17175
17176  @Pure
17177  @Override
17178  public boolean isRshiftUnsigned() {
17179    return true;
17180  }
17181
17182  /** Returns a list of non-instantiating suppressions for this invariant. */
17183  @Pure
17184  @Override
17185  public @Nullable NISuppressionSet get_ni_suppressions() {
17186    if (NIS.dkconfig_enabled && dkconfig_enabled) {
17187      return suppressions;
17188    } else {
17189      return null;
17190    }
17191  }
17192
17193  /** definition of this invariant (the suppressee) */
17194  private static NISuppressee suppressee = new NISuppressee(RshiftUnsignedLong_zxy.class, 3);
17195
17196  // suppressor definitions (used below)
17197  private static NISuppressor result_eq_arg1 =
17198      new NISuppressor(2, 0, IntEqual.class);
17199  private static NISuppressor result_eq_arg2 =
17200      new NISuppressor(2, 1, IntEqual.class);
17201  private static NISuppressor arg1_eq_arg2 =
17202      new NISuppressor(0, 1, IntEqual.class);
17203
17204  private static NISuppressor result_lt_arg1 =
17205      new NISuppressor(2, 0, IntLessThan.class);
17206  private static NISuppressor result_lt_arg2 =
17207      new NISuppressor(2, 1, IntLessThan.class);
17208  private static NISuppressor arg1_lt_arg2 =
17209      new NISuppressor(0, 1, IntLessThan.class);
17210  private static NISuppressor arg2_lt_arg1 =
17211      new NISuppressor(1, 0, IntLessThan.class);
17212
17213  private static NISuppressor result_le_arg1 =
17214      new NISuppressor(2, 0, IntLessEqual.class);
17215  private static NISuppressor result_le_arg2 =
17216      new NISuppressor(2, 1, IntLessEqual.class);
17217  private static NISuppressor arg1_le_arg2 =
17218      new NISuppressor(0, 1, IntLessEqual.class);
17219  private static NISuppressor arg2_le_arg1 =
17220      new NISuppressor(1, 0, IntLessEqual.class);
17221
17222  private static NISuppressor result_track0_arg1 =
17223      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
17224  private static NISuppressor result_track0_arg2 =
17225      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
17226  private static NISuppressor arg1_track0_arg2 =
17227      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
17228  private static NISuppressor arg1_track0_result =
17229      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
17230  private static NISuppressor arg2_track0_result =
17231      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
17232  private static NISuppressor arg2_track0_arg1 =
17233      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
17234
17235  private static NISuppressor result_eq_1 =
17236      new NISuppressor(2, RangeInt.EqualOne.class);
17237  private static NISuppressor arg1_eq_1 =
17238      new NISuppressor(0, RangeInt.EqualOne.class);
17239  private static NISuppressor arg2_eq_1 =
17240      new NISuppressor(1, RangeInt.EqualOne.class);
17241
17242  private static NISuppressor result_eq_0 =
17243      new NISuppressor(2, RangeInt.EqualZero.class);
17244  private static NISuppressor arg1_eq_0 =
17245      new NISuppressor(0, RangeInt.EqualZero.class);
17246  private static NISuppressor arg2_eq_0 =
17247      new NISuppressor(1, RangeInt.EqualZero.class);
17248
17249  private static NISuppressor result_ne_0 =
17250      new NISuppressor(2, NonZero.class);
17251  private static NISuppressor arg1_ne_0 =
17252      new NISuppressor(0, NonZero.class);
17253  private static NISuppressor arg2_ne_0 =
17254      new NISuppressor(1, NonZero.class);
17255
17256  private static NISuppressor result_ge_0 =
17257      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
17258  private static NISuppressor arg1_ge_0 =
17259      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
17260  private static NISuppressor arg2_ge_0 =
17261      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
17262
17263  private static NISuppressor result_ge_64 =
17264      new NISuppressor(2, RangeInt.GreaterEqual64.class);
17265  private static NISuppressor arg1_ge_64 =
17266      new NISuppressor(0, RangeInt.GreaterEqual64.class);
17267  private static NISuppressor arg2_ge_64 =
17268      new NISuppressor(1, RangeInt.GreaterEqual64.class);
17269
17270  private static NISuppressor result_boolean =
17271      new NISuppressor(2, RangeInt.BooleanVal.class);
17272  private static NISuppressor arg1_boolean =
17273      new NISuppressor(0, RangeInt.BooleanVal.class);
17274  private static NISuppressor arg2_boolean =
17275      new NISuppressor(1, RangeInt.BooleanVal.class);
17276
17277  private static NISuppressor result_even =
17278      new NISuppressor(2, RangeInt.Even.class);
17279  private static NISuppressor arg1_even =
17280      new NISuppressor(0, RangeInt.Even.class);
17281  private static NISuppressor arg2_even =
17282      new NISuppressor(1, RangeInt.Even.class);
17283
17284  private static NISuppressor result_power2 =
17285      new NISuppressor(2, RangeInt.PowerOfTwo.class);
17286  private static NISuppressor arg1_power2 =
17287      new NISuppressor(0, RangeInt.PowerOfTwo.class);
17288  private static NISuppressor arg2_power2 =
17289      new NISuppressor(1, RangeInt.PowerOfTwo.class);
17290
17291  private static NISuppressor result_and0_arg1 =
17292      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
17293  private static NISuppressor result_and0_arg2 =
17294      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
17295  private static NISuppressor arg1_and0_arg2 =
17296      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
17297
17298  // The arguments to bitwise subset are backwards from what one
17299  // might expect.  The second argument is a subset of the first
17300  // argument
17301  private static NISuppressor arg1_bw_subset_arg2 =
17302      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
17303  private static NISuppressor arg2_bw_subset_arg1 =
17304      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
17305
17306  private static NISuppressor result_shift0_arg1 =
17307      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
17308  private static NISuppressor result_shift0_arg2 =
17309      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
17310  private static NISuppressor arg1_shift0_arg2 =
17311      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
17312
17313  private static NISuppressor arg2_divides_arg1 =
17314      new NISuppressor(0, 1, NumericInt.Divides.class);
17315  private static NISuppressor arg1_divides_arg2 =
17316      new NISuppressor(1, 0, NumericInt.Divides.class);
17317
17318  private static NISuppressor arg2_valid_shift =
17319      new NISuppressor(1, RangeInt.Bound0_63.class);
17320
17321    private static NISuppressionSet suppressions =
17322        new NISuppressionSet(
17323          new NISuppression[] {
17324
17325            // (r == x) && (y == 0) ==> r = x >>> y
17326            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
17327
17328            // (r == 0) && (x == 0) && (y valid shift) ==> r = x >>> y
17329            // new NISuppression (result_eq_0, arg1_eq_0, arg2_valid_shift, suppressee),
17330
17331            // (r == 0) && ((x >> y) == 0)
17332            new NISuppression(result_eq_0, arg1_shift0_arg2, suppressee),
17333
17334            // (r == 0) && (y >= x) && (x >= 0) && (y valid shift)
17335            // This suppression really ought to have 2**y >= x, but we
17336            // don't have that suppression.  This still might catch a lot of these.
17337            // new NISuppression (result_eq_0, arg1_le_arg2, arg1_ge_0,
17338            //                   arg2_valid_shift, suppressee),
17339          });
17340
17341  // Create a suppression factory for functionBinary
17342
17343}
17344
17345/**
17346 * Represents the invariant {@code x = RshiftUnsigned(z, y)} over three long
17347 * scalars. 
17348 */
17349public static class RshiftUnsignedLong_xzy extends FunctionBinary {
17350  // We are Serializable, so we specify a version to allow changes to
17351  // method signatures without breaking serialization.  If you add or
17352  // remove fields, you should change this number to the current date.
17353  static final long serialVersionUID = 20031030L;
17354
17355    // y must be between arg2_bound[0] and arg2_bound[1] inclusive
17356    static int[] arg2_bound = {0, 63};
17357
17358  private static @Prototype RshiftUnsignedLong_xzy proto = new @Prototype RshiftUnsignedLong_xzy ();
17359
17360  /** Returns the prototype invariant for RshiftUnsignedLong_xzy */
17361  public static @Prototype RshiftUnsignedLong_xzy get_proto() {
17362    return proto;
17363  }
17364
17365  /** instantiate an invariant on the specified slice */
17366  @Override
17367  protected RshiftUnsignedLong_xzy instantiate_dyn(@Prototype RshiftUnsignedLong_xzy this, PptSlice slice) {
17368    return new RshiftUnsignedLong_xzy (slice);
17369  }
17370
17371  private RshiftUnsignedLong_xzy (PptSlice slice) {
17372    super(slice);
17373  }
17374
17375  public @Prototype RshiftUnsignedLong_xzy () {
17376    super();
17377  }
17378
17379  private static String[] method_name = new String[] {"", " >>> ", ""};
17380
17381  @Override
17382  public String[] get_method_name(@GuardSatisfied RshiftUnsignedLong_xzy this) {
17383    return method_name;
17384  }
17385
17386  private static int function_id = -1;
17387
17388  @Override
17389  public int get_function_id() {
17390    return function_id;
17391  }
17392
17393  @Override
17394  public void set_function_id(int function_id) {
17395    assert RshiftUnsignedLong_xzy.function_id == -1;
17396    RshiftUnsignedLong_xzy.function_id = function_id;
17397  }
17398
17399  private static int var_order = 4;
17400
17401  @Override
17402  public int get_var_order(@GuardSatisfied RshiftUnsignedLong_xzy this) {
17403    return var_order;
17404  }
17405
17406  @Pure
17407  @Override
17408  public boolean is_symmetric() {
17409
17410      return false;
17411  }
17412
17413  @Override
17414
17415  @SuppressWarnings("signedness:shift.unsigned") // RshiftUnsigned treats z as unsigned, though we do not know how the program under test treats it
17416
17417  public long func(long z, long y) {
17418
17419      if ((y < arg2_bound[0]) || (y > arg2_bound[1])) {
17420        throw new ArithmeticException("arg2 (" + y + ") out of range "
17421                                       + arg2_bound[0] + ".." + arg2_bound[1]);
17422      }
17423
17424    return (z >>> y);
17425  }
17426
17427  @Override
17428  public InvariantStatus check_modified(long x, long y,
17429                                      long z, int count) {
17430    return check_ordered(x, z, y, count);
17431  }
17432
17433  @Override
17434  public InvariantStatus add_modified(long x, long y,
17435                                      long z, int count) {
17436    if (Debug.logDetail()) {
17437      log("result=%s, arg1=%s, arg2=%s", x, z, y);
17438    }
17439    return add_ordered(x, z, y, count);
17440  }
17441
17442  @Pure
17443  @Override
17444  public boolean isRshiftUnsigned() {
17445    return true;
17446  }
17447
17448  /** Returns a list of non-instantiating suppressions for this invariant. */
17449  @Pure
17450  @Override
17451  public @Nullable NISuppressionSet get_ni_suppressions() {
17452    if (NIS.dkconfig_enabled && dkconfig_enabled) {
17453      return suppressions;
17454    } else {
17455      return null;
17456    }
17457  }
17458
17459  /** definition of this invariant (the suppressee) */
17460  private static NISuppressee suppressee = new NISuppressee(RshiftUnsignedLong_xzy.class, 3);
17461
17462  // suppressor definitions (used below)
17463  private static NISuppressor result_eq_arg1 =
17464      new NISuppressor(0, 2, IntEqual.class);
17465  private static NISuppressor result_eq_arg2 =
17466      new NISuppressor(0, 1, IntEqual.class);
17467  private static NISuppressor arg1_eq_arg2 =
17468      new NISuppressor(2, 1, IntEqual.class);
17469
17470  private static NISuppressor result_lt_arg1 =
17471      new NISuppressor(0, 2, IntLessThan.class);
17472  private static NISuppressor result_lt_arg2 =
17473      new NISuppressor(0, 1, IntLessThan.class);
17474  private static NISuppressor arg1_lt_arg2 =
17475      new NISuppressor(2, 1, IntLessThan.class);
17476  private static NISuppressor arg2_lt_arg1 =
17477      new NISuppressor(1, 2, IntLessThan.class);
17478
17479  private static NISuppressor result_le_arg1 =
17480      new NISuppressor(0, 2, IntLessEqual.class);
17481  private static NISuppressor result_le_arg2 =
17482      new NISuppressor(0, 1, IntLessEqual.class);
17483  private static NISuppressor arg1_le_arg2 =
17484      new NISuppressor(2, 1, IntLessEqual.class);
17485  private static NISuppressor arg2_le_arg1 =
17486      new NISuppressor(1, 2, IntLessEqual.class);
17487
17488  private static NISuppressor result_track0_arg1 =
17489      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
17490  private static NISuppressor result_track0_arg2 =
17491      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
17492  private static NISuppressor arg1_track0_arg2 =
17493      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
17494  private static NISuppressor arg1_track0_result =
17495      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
17496  private static NISuppressor arg2_track0_result =
17497      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
17498  private static NISuppressor arg2_track0_arg1 =
17499      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
17500
17501  private static NISuppressor result_eq_1 =
17502      new NISuppressor(0, RangeInt.EqualOne.class);
17503  private static NISuppressor arg1_eq_1 =
17504      new NISuppressor(2, RangeInt.EqualOne.class);
17505  private static NISuppressor arg2_eq_1 =
17506      new NISuppressor(1, RangeInt.EqualOne.class);
17507
17508  private static NISuppressor result_eq_0 =
17509      new NISuppressor(0, RangeInt.EqualZero.class);
17510  private static NISuppressor arg1_eq_0 =
17511      new NISuppressor(2, RangeInt.EqualZero.class);
17512  private static NISuppressor arg2_eq_0 =
17513      new NISuppressor(1, RangeInt.EqualZero.class);
17514
17515  private static NISuppressor result_ne_0 =
17516      new NISuppressor(0, NonZero.class);
17517  private static NISuppressor arg1_ne_0 =
17518      new NISuppressor(2, NonZero.class);
17519  private static NISuppressor arg2_ne_0 =
17520      new NISuppressor(1, NonZero.class);
17521
17522  private static NISuppressor result_ge_0 =
17523      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
17524  private static NISuppressor arg1_ge_0 =
17525      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
17526  private static NISuppressor arg2_ge_0 =
17527      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
17528
17529  private static NISuppressor result_ge_64 =
17530      new NISuppressor(0, RangeInt.GreaterEqual64.class);
17531  private static NISuppressor arg1_ge_64 =
17532      new NISuppressor(2, RangeInt.GreaterEqual64.class);
17533  private static NISuppressor arg2_ge_64 =
17534      new NISuppressor(1, RangeInt.GreaterEqual64.class);
17535
17536  private static NISuppressor result_boolean =
17537      new NISuppressor(0, RangeInt.BooleanVal.class);
17538  private static NISuppressor arg1_boolean =
17539      new NISuppressor(2, RangeInt.BooleanVal.class);
17540  private static NISuppressor arg2_boolean =
17541      new NISuppressor(1, RangeInt.BooleanVal.class);
17542
17543  private static NISuppressor result_even =
17544      new NISuppressor(0, RangeInt.Even.class);
17545  private static NISuppressor arg1_even =
17546      new NISuppressor(2, RangeInt.Even.class);
17547  private static NISuppressor arg2_even =
17548      new NISuppressor(1, RangeInt.Even.class);
17549
17550  private static NISuppressor result_power2 =
17551      new NISuppressor(0, RangeInt.PowerOfTwo.class);
17552  private static NISuppressor arg1_power2 =
17553      new NISuppressor(2, RangeInt.PowerOfTwo.class);
17554  private static NISuppressor arg2_power2 =
17555      new NISuppressor(1, RangeInt.PowerOfTwo.class);
17556
17557  private static NISuppressor result_and0_arg1 =
17558      new NISuppressor(0, 2, NumericInt.BitwiseAndZero.class);
17559  private static NISuppressor result_and0_arg2 =
17560      new NISuppressor(0, 1, NumericInt.BitwiseAndZero.class);
17561  private static NISuppressor arg1_and0_arg2 =
17562      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
17563
17564  // The arguments to bitwise subset are backwards from what one
17565  // might expect.  The second argument is a subset of the first
17566  // argument
17567  private static NISuppressor arg1_bw_subset_arg2 =
17568      new NISuppressor(1, 2, NumericInt.BitwiseSubset.class);
17569  private static NISuppressor arg2_bw_subset_arg1 =
17570      new NISuppressor(2, 1, NumericInt.BitwiseSubset.class);
17571
17572  private static NISuppressor result_shift0_arg1 =
17573      new NISuppressor(0, 2, NumericInt.ShiftZero.class);
17574  private static NISuppressor result_shift0_arg2 =
17575      new NISuppressor(0, 1, NumericInt.ShiftZero.class);
17576  private static NISuppressor arg1_shift0_arg2 =
17577      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
17578
17579  private static NISuppressor arg2_divides_arg1 =
17580      new NISuppressor(2, 1, NumericInt.Divides.class);
17581  private static NISuppressor arg1_divides_arg2 =
17582      new NISuppressor(1, 2, NumericInt.Divides.class);
17583
17584  private static NISuppressor arg2_valid_shift =
17585      new NISuppressor(1, RangeInt.Bound0_63.class);
17586
17587    private static NISuppressionSet suppressions =
17588        new NISuppressionSet(
17589          new NISuppression[] {
17590
17591            // (r == z) && (y == 0) ==> r = z >>> y
17592            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
17593
17594            // (r == 0) && (z == 0) && (y valid shift) ==> r = z >>> y
17595            // new NISuppression (result_eq_0, arg1_eq_0, arg2_valid_shift, suppressee),
17596
17597            // (r == 0) && ((z >> y) == 0)
17598            new NISuppression(result_eq_0, arg1_shift0_arg2, suppressee),
17599
17600            // (r == 0) && (y >= z) && (z >= 0) && (y valid shift)
17601            // This suppression really ought to have 2**y >= z, but we
17602            // don't have that suppression.  This still might catch a lot of these.
17603            // new NISuppression (result_eq_0, arg1_le_arg2, arg1_ge_0,
17604            //                   arg2_valid_shift, suppressee),
17605          });
17606
17607  // Create a suppression factory for functionBinary
17608
17609}
17610
17611/**
17612 * Represents the invariant {@code y = RshiftUnsigned(z, x)} over three long
17613 * scalars. 
17614 */
17615public static class RshiftUnsignedLong_yzx extends FunctionBinary {
17616  // We are Serializable, so we specify a version to allow changes to
17617  // method signatures without breaking serialization.  If you add or
17618  // remove fields, you should change this number to the current date.
17619  static final long serialVersionUID = 20031030L;
17620
17621    // x must be between arg2_bound[0] and arg2_bound[1] inclusive
17622    static int[] arg2_bound = {0, 63};
17623
17624  private static @Prototype RshiftUnsignedLong_yzx proto = new @Prototype RshiftUnsignedLong_yzx ();
17625
17626  /** Returns the prototype invariant for RshiftUnsignedLong_yzx */
17627  public static @Prototype RshiftUnsignedLong_yzx get_proto() {
17628    return proto;
17629  }
17630
17631  /** instantiate an invariant on the specified slice */
17632  @Override
17633  protected RshiftUnsignedLong_yzx instantiate_dyn(@Prototype RshiftUnsignedLong_yzx this, PptSlice slice) {
17634    return new RshiftUnsignedLong_yzx (slice);
17635  }
17636
17637  private RshiftUnsignedLong_yzx (PptSlice slice) {
17638    super(slice);
17639  }
17640
17641  public @Prototype RshiftUnsignedLong_yzx () {
17642    super();
17643  }
17644
17645  private static String[] method_name = new String[] {"", " >>> ", ""};
17646
17647  @Override
17648  public String[] get_method_name(@GuardSatisfied RshiftUnsignedLong_yzx this) {
17649    return method_name;
17650  }
17651
17652  private static int function_id = -1;
17653
17654  @Override
17655  public int get_function_id() {
17656    return function_id;
17657  }
17658
17659  @Override
17660  public void set_function_id(int function_id) {
17661    assert RshiftUnsignedLong_yzx.function_id == -1;
17662    RshiftUnsignedLong_yzx.function_id = function_id;
17663  }
17664
17665  private static int var_order = 5;
17666
17667  @Override
17668  public int get_var_order(@GuardSatisfied RshiftUnsignedLong_yzx this) {
17669    return var_order;
17670  }
17671
17672  @Pure
17673  @Override
17674  public boolean is_symmetric() {
17675
17676      return false;
17677  }
17678
17679  @Override
17680
17681  @SuppressWarnings("signedness:shift.unsigned") // RshiftUnsigned treats z as unsigned, though we do not know how the program under test treats it
17682
17683  public long func(long z, long x) {
17684
17685      if ((x < arg2_bound[0]) || (x > arg2_bound[1])) {
17686        throw new ArithmeticException("arg2 (" + x + ") out of range "
17687                                       + arg2_bound[0] + ".." + arg2_bound[1]);
17688      }
17689
17690    return (z >>> x);
17691  }
17692
17693  @Override
17694  public InvariantStatus check_modified(long x, long y,
17695                                      long z, int count) {
17696    return check_ordered(y, z, x, count);
17697  }
17698
17699  @Override
17700  public InvariantStatus add_modified(long x, long y,
17701                                      long z, int count) {
17702    if (Debug.logDetail()) {
17703      log("result=%s, arg1=%s, arg2=%s", y, z, x);
17704    }
17705    return add_ordered(y, z, x, count);
17706  }
17707
17708  @Pure
17709  @Override
17710  public boolean isRshiftUnsigned() {
17711    return true;
17712  }
17713
17714  /** Returns a list of non-instantiating suppressions for this invariant. */
17715  @Pure
17716  @Override
17717  public @Nullable NISuppressionSet get_ni_suppressions() {
17718    if (NIS.dkconfig_enabled && dkconfig_enabled) {
17719      return suppressions;
17720    } else {
17721      return null;
17722    }
17723  }
17724
17725  /** definition of this invariant (the suppressee) */
17726  private static NISuppressee suppressee = new NISuppressee(RshiftUnsignedLong_yzx.class, 3);
17727
17728  // suppressor definitions (used below)
17729  private static NISuppressor result_eq_arg1 =
17730      new NISuppressor(1, 2, IntEqual.class);
17731  private static NISuppressor result_eq_arg2 =
17732      new NISuppressor(1, 0, IntEqual.class);
17733  private static NISuppressor arg1_eq_arg2 =
17734      new NISuppressor(2, 0, IntEqual.class);
17735
17736  private static NISuppressor result_lt_arg1 =
17737      new NISuppressor(1, 2, IntLessThan.class);
17738  private static NISuppressor result_lt_arg2 =
17739      new NISuppressor(1, 0, IntLessThan.class);
17740  private static NISuppressor arg1_lt_arg2 =
17741      new NISuppressor(2, 0, IntLessThan.class);
17742  private static NISuppressor arg2_lt_arg1 =
17743      new NISuppressor(0, 2, IntLessThan.class);
17744
17745  private static NISuppressor result_le_arg1 =
17746      new NISuppressor(1, 2, IntLessEqual.class);
17747  private static NISuppressor result_le_arg2 =
17748      new NISuppressor(1, 0, IntLessEqual.class);
17749  private static NISuppressor arg1_le_arg2 =
17750      new NISuppressor(2, 0, IntLessEqual.class);
17751  private static NISuppressor arg2_le_arg1 =
17752      new NISuppressor(0, 2, IntLessEqual.class);
17753
17754  private static NISuppressor result_track0_arg1 =
17755      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
17756  private static NISuppressor result_track0_arg2 =
17757      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
17758  private static NISuppressor arg1_track0_arg2 =
17759      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
17760  private static NISuppressor arg1_track0_result =
17761      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
17762  private static NISuppressor arg2_track0_result =
17763      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
17764  private static NISuppressor arg2_track0_arg1 =
17765      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
17766
17767  private static NISuppressor result_eq_1 =
17768      new NISuppressor(1, RangeInt.EqualOne.class);
17769  private static NISuppressor arg1_eq_1 =
17770      new NISuppressor(2, RangeInt.EqualOne.class);
17771  private static NISuppressor arg2_eq_1 =
17772      new NISuppressor(0, RangeInt.EqualOne.class);
17773
17774  private static NISuppressor result_eq_0 =
17775      new NISuppressor(1, RangeInt.EqualZero.class);
17776  private static NISuppressor arg1_eq_0 =
17777      new NISuppressor(2, RangeInt.EqualZero.class);
17778  private static NISuppressor arg2_eq_0 =
17779      new NISuppressor(0, RangeInt.EqualZero.class);
17780
17781  private static NISuppressor result_ne_0 =
17782      new NISuppressor(1, NonZero.class);
17783  private static NISuppressor arg1_ne_0 =
17784      new NISuppressor(2, NonZero.class);
17785  private static NISuppressor arg2_ne_0 =
17786      new NISuppressor(0, NonZero.class);
17787
17788  private static NISuppressor result_ge_0 =
17789      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
17790  private static NISuppressor arg1_ge_0 =
17791      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
17792  private static NISuppressor arg2_ge_0 =
17793      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
17794
17795  private static NISuppressor result_ge_64 =
17796      new NISuppressor(1, RangeInt.GreaterEqual64.class);
17797  private static NISuppressor arg1_ge_64 =
17798      new NISuppressor(2, RangeInt.GreaterEqual64.class);
17799  private static NISuppressor arg2_ge_64 =
17800      new NISuppressor(0, RangeInt.GreaterEqual64.class);
17801
17802  private static NISuppressor result_boolean =
17803      new NISuppressor(1, RangeInt.BooleanVal.class);
17804  private static NISuppressor arg1_boolean =
17805      new NISuppressor(2, RangeInt.BooleanVal.class);
17806  private static NISuppressor arg2_boolean =
17807      new NISuppressor(0, RangeInt.BooleanVal.class);
17808
17809  private static NISuppressor result_even =
17810      new NISuppressor(1, RangeInt.Even.class);
17811  private static NISuppressor arg1_even =
17812      new NISuppressor(2, RangeInt.Even.class);
17813  private static NISuppressor arg2_even =
17814      new NISuppressor(0, RangeInt.Even.class);
17815
17816  private static NISuppressor result_power2 =
17817      new NISuppressor(1, RangeInt.PowerOfTwo.class);
17818  private static NISuppressor arg1_power2 =
17819      new NISuppressor(2, RangeInt.PowerOfTwo.class);
17820  private static NISuppressor arg2_power2 =
17821      new NISuppressor(0, RangeInt.PowerOfTwo.class);
17822
17823  private static NISuppressor result_and0_arg1 =
17824      new NISuppressor(1, 2, NumericInt.BitwiseAndZero.class);
17825  private static NISuppressor result_and0_arg2 =
17826      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
17827  private static NISuppressor arg1_and0_arg2 =
17828      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
17829
17830  // The arguments to bitwise subset are backwards from what one
17831  // might expect.  The second argument is a subset of the first
17832  // argument
17833  private static NISuppressor arg1_bw_subset_arg2 =
17834      new NISuppressor(0, 2, NumericInt.BitwiseSubset.class);
17835  private static NISuppressor arg2_bw_subset_arg1 =
17836      new NISuppressor(2, 0, NumericInt.BitwiseSubset.class);
17837
17838  private static NISuppressor result_shift0_arg1 =
17839      new NISuppressor(1, 2, NumericInt.ShiftZero.class);
17840  private static NISuppressor result_shift0_arg2 =
17841      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
17842  private static NISuppressor arg1_shift0_arg2 =
17843      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
17844
17845  private static NISuppressor arg2_divides_arg1 =
17846      new NISuppressor(2, 0, NumericInt.Divides.class);
17847  private static NISuppressor arg1_divides_arg2 =
17848      new NISuppressor(0, 2, NumericInt.Divides.class);
17849
17850  private static NISuppressor arg2_valid_shift =
17851      new NISuppressor(0, RangeInt.Bound0_63.class);
17852
17853    private static NISuppressionSet suppressions =
17854        new NISuppressionSet(
17855          new NISuppression[] {
17856
17857            // (r == z) && (x == 0) ==> r = z >>> x
17858            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
17859
17860            // (r == 0) && (z == 0) && (x valid shift) ==> r = z >>> x
17861            // new NISuppression (result_eq_0, arg1_eq_0, arg2_valid_shift, suppressee),
17862
17863            // (r == 0) && ((z >> x) == 0)
17864            new NISuppression(result_eq_0, arg1_shift0_arg2, suppressee),
17865
17866            // (r == 0) && (x >= z) && (z >= 0) && (x valid shift)
17867            // This suppression really ought to have 2**x >= z, but we
17868            // don't have that suppression.  This still might catch a lot of these.
17869            // new NISuppression (result_eq_0, arg1_le_arg2, arg1_ge_0,
17870            //                   arg2_valid_shift, suppressee),
17871          });
17872
17873  // Create a suppression factory for functionBinary
17874
17875}
17876
17877/**
17878 * Represents the invariant {@code z = RshiftUnsigned(y, x)} over three long
17879 * scalars. 
17880 */
17881public static class RshiftUnsignedLong_zyx extends FunctionBinary {
17882  // We are Serializable, so we specify a version to allow changes to
17883  // method signatures without breaking serialization.  If you add or
17884  // remove fields, you should change this number to the current date.
17885  static final long serialVersionUID = 20031030L;
17886
17887    // x must be between arg2_bound[0] and arg2_bound[1] inclusive
17888    static int[] arg2_bound = {0, 63};
17889
17890  private static @Prototype RshiftUnsignedLong_zyx proto = new @Prototype RshiftUnsignedLong_zyx ();
17891
17892  /** Returns the prototype invariant for RshiftUnsignedLong_zyx */
17893  public static @Prototype RshiftUnsignedLong_zyx get_proto() {
17894    return proto;
17895  }
17896
17897  /** instantiate an invariant on the specified slice */
17898  @Override
17899  protected RshiftUnsignedLong_zyx instantiate_dyn(@Prototype RshiftUnsignedLong_zyx this, PptSlice slice) {
17900    return new RshiftUnsignedLong_zyx (slice);
17901  }
17902
17903  private RshiftUnsignedLong_zyx (PptSlice slice) {
17904    super(slice);
17905  }
17906
17907  public @Prototype RshiftUnsignedLong_zyx () {
17908    super();
17909  }
17910
17911  private static String[] method_name = new String[] {"", " >>> ", ""};
17912
17913  @Override
17914  public String[] get_method_name(@GuardSatisfied RshiftUnsignedLong_zyx this) {
17915    return method_name;
17916  }
17917
17918  private static int function_id = -1;
17919
17920  @Override
17921  public int get_function_id() {
17922    return function_id;
17923  }
17924
17925  @Override
17926  public void set_function_id(int function_id) {
17927    assert RshiftUnsignedLong_zyx.function_id == -1;
17928    RshiftUnsignedLong_zyx.function_id = function_id;
17929  }
17930
17931  private static int var_order = 6;
17932
17933  @Override
17934  public int get_var_order(@GuardSatisfied RshiftUnsignedLong_zyx this) {
17935    return var_order;
17936  }
17937
17938  @Pure
17939  @Override
17940  public boolean is_symmetric() {
17941
17942      return false;
17943  }
17944
17945  @Override
17946
17947  @SuppressWarnings("signedness:shift.unsigned") // RshiftUnsigned treats y as unsigned, though we do not know how the program under test treats it
17948
17949  public long func(long y, long x) {
17950
17951      if ((x < arg2_bound[0]) || (x > arg2_bound[1])) {
17952        throw new ArithmeticException("arg2 (" + x + ") out of range "
17953                                       + arg2_bound[0] + ".." + arg2_bound[1]);
17954      }
17955
17956    return (y >>> x);
17957  }
17958
17959  @Override
17960  public InvariantStatus check_modified(long x, long y,
17961                                      long z, int count) {
17962    return check_ordered(z, y, x, count);
17963  }
17964
17965  @Override
17966  public InvariantStatus add_modified(long x, long y,
17967                                      long z, int count) {
17968    if (Debug.logDetail()) {
17969      log("result=%s, arg1=%s, arg2=%s", z, y, x);
17970    }
17971    return add_ordered(z, y, x, count);
17972  }
17973
17974  @Pure
17975  @Override
17976  public boolean isRshiftUnsigned() {
17977    return true;
17978  }
17979
17980  /** Returns a list of non-instantiating suppressions for this invariant. */
17981  @Pure
17982  @Override
17983  public @Nullable NISuppressionSet get_ni_suppressions() {
17984    if (NIS.dkconfig_enabled && dkconfig_enabled) {
17985      return suppressions;
17986    } else {
17987      return null;
17988    }
17989  }
17990
17991  /** definition of this invariant (the suppressee) */
17992  private static NISuppressee suppressee = new NISuppressee(RshiftUnsignedLong_zyx.class, 3);
17993
17994  // suppressor definitions (used below)
17995  private static NISuppressor result_eq_arg1 =
17996      new NISuppressor(2, 1, IntEqual.class);
17997  private static NISuppressor result_eq_arg2 =
17998      new NISuppressor(2, 0, IntEqual.class);
17999  private static NISuppressor arg1_eq_arg2 =
18000      new NISuppressor(1, 0, IntEqual.class);
18001
18002  private static NISuppressor result_lt_arg1 =
18003      new NISuppressor(2, 1, IntLessThan.class);
18004  private static NISuppressor result_lt_arg2 =
18005      new NISuppressor(2, 0, IntLessThan.class);
18006  private static NISuppressor arg1_lt_arg2 =
18007      new NISuppressor(1, 0, IntLessThan.class);
18008  private static NISuppressor arg2_lt_arg1 =
18009      new NISuppressor(0, 1, IntLessThan.class);
18010
18011  private static NISuppressor result_le_arg1 =
18012      new NISuppressor(2, 1, IntLessEqual.class);
18013  private static NISuppressor result_le_arg2 =
18014      new NISuppressor(2, 0, IntLessEqual.class);
18015  private static NISuppressor arg1_le_arg2 =
18016      new NISuppressor(1, 0, IntLessEqual.class);
18017  private static NISuppressor arg2_le_arg1 =
18018      new NISuppressor(0, 1, IntLessEqual.class);
18019
18020  private static NISuppressor result_track0_arg1 =
18021      new NISuppressor(2, 1, NumericInt.ZeroTrack.class);
18022  private static NISuppressor result_track0_arg2 =
18023      new NISuppressor(2, 0, NumericInt.ZeroTrack.class);
18024  private static NISuppressor arg1_track0_arg2 =
18025      new NISuppressor(1, 0, NumericInt.ZeroTrack.class);
18026  private static NISuppressor arg1_track0_result =
18027      new NISuppressor(1, 2, NumericInt.ZeroTrack.class);
18028  private static NISuppressor arg2_track0_result =
18029      new NISuppressor(0, 2, NumericInt.ZeroTrack.class);
18030  private static NISuppressor arg2_track0_arg1 =
18031      new NISuppressor(0, 1, NumericInt.ZeroTrack.class);
18032
18033  private static NISuppressor result_eq_1 =
18034      new NISuppressor(2, RangeInt.EqualOne.class);
18035  private static NISuppressor arg1_eq_1 =
18036      new NISuppressor(1, RangeInt.EqualOne.class);
18037  private static NISuppressor arg2_eq_1 =
18038      new NISuppressor(0, RangeInt.EqualOne.class);
18039
18040  private static NISuppressor result_eq_0 =
18041      new NISuppressor(2, RangeInt.EqualZero.class);
18042  private static NISuppressor arg1_eq_0 =
18043      new NISuppressor(1, RangeInt.EqualZero.class);
18044  private static NISuppressor arg2_eq_0 =
18045      new NISuppressor(0, RangeInt.EqualZero.class);
18046
18047  private static NISuppressor result_ne_0 =
18048      new NISuppressor(2, NonZero.class);
18049  private static NISuppressor arg1_ne_0 =
18050      new NISuppressor(1, NonZero.class);
18051  private static NISuppressor arg2_ne_0 =
18052      new NISuppressor(0, NonZero.class);
18053
18054  private static NISuppressor result_ge_0 =
18055      new NISuppressor(2, RangeInt.GreaterEqualZero.class);
18056  private static NISuppressor arg1_ge_0 =
18057      new NISuppressor(1, RangeInt.GreaterEqualZero.class);
18058  private static NISuppressor arg2_ge_0 =
18059      new NISuppressor(0, RangeInt.GreaterEqualZero.class);
18060
18061  private static NISuppressor result_ge_64 =
18062      new NISuppressor(2, RangeInt.GreaterEqual64.class);
18063  private static NISuppressor arg1_ge_64 =
18064      new NISuppressor(1, RangeInt.GreaterEqual64.class);
18065  private static NISuppressor arg2_ge_64 =
18066      new NISuppressor(0, RangeInt.GreaterEqual64.class);
18067
18068  private static NISuppressor result_boolean =
18069      new NISuppressor(2, RangeInt.BooleanVal.class);
18070  private static NISuppressor arg1_boolean =
18071      new NISuppressor(1, RangeInt.BooleanVal.class);
18072  private static NISuppressor arg2_boolean =
18073      new NISuppressor(0, RangeInt.BooleanVal.class);
18074
18075  private static NISuppressor result_even =
18076      new NISuppressor(2, RangeInt.Even.class);
18077  private static NISuppressor arg1_even =
18078      new NISuppressor(1, RangeInt.Even.class);
18079  private static NISuppressor arg2_even =
18080      new NISuppressor(0, RangeInt.Even.class);
18081
18082  private static NISuppressor result_power2 =
18083      new NISuppressor(2, RangeInt.PowerOfTwo.class);
18084  private static NISuppressor arg1_power2 =
18085      new NISuppressor(1, RangeInt.PowerOfTwo.class);
18086  private static NISuppressor arg2_power2 =
18087      new NISuppressor(0, RangeInt.PowerOfTwo.class);
18088
18089  private static NISuppressor result_and0_arg1 =
18090      new NISuppressor(2, 1, NumericInt.BitwiseAndZero.class);
18091  private static NISuppressor result_and0_arg2 =
18092      new NISuppressor(2, 0, NumericInt.BitwiseAndZero.class);
18093  private static NISuppressor arg1_and0_arg2 =
18094      new NISuppressor(1, 0, NumericInt.BitwiseAndZero.class);
18095
18096  // The arguments to bitwise subset are backwards from what one
18097  // might expect.  The second argument is a subset of the first
18098  // argument
18099  private static NISuppressor arg1_bw_subset_arg2 =
18100      new NISuppressor(0, 1, NumericInt.BitwiseSubset.class);
18101  private static NISuppressor arg2_bw_subset_arg1 =
18102      new NISuppressor(1, 0, NumericInt.BitwiseSubset.class);
18103
18104  private static NISuppressor result_shift0_arg1 =
18105      new NISuppressor(2, 1, NumericInt.ShiftZero.class);
18106  private static NISuppressor result_shift0_arg2 =
18107      new NISuppressor(2, 0, NumericInt.ShiftZero.class);
18108  private static NISuppressor arg1_shift0_arg2 =
18109      new NISuppressor(1, 0, NumericInt.ShiftZero.class);
18110
18111  private static NISuppressor arg2_divides_arg1 =
18112      new NISuppressor(1, 0, NumericInt.Divides.class);
18113  private static NISuppressor arg1_divides_arg2 =
18114      new NISuppressor(0, 1, NumericInt.Divides.class);
18115
18116  private static NISuppressor arg2_valid_shift =
18117      new NISuppressor(0, RangeInt.Bound0_63.class);
18118
18119    private static NISuppressionSet suppressions =
18120        new NISuppressionSet(
18121          new NISuppression[] {
18122
18123            // (r == y) && (x == 0) ==> r = y >>> x
18124            new NISuppression(result_eq_arg1, arg2_eq_0, suppressee),
18125
18126            // (r == 0) && (y == 0) && (x valid shift) ==> r = y >>> x
18127            // new NISuppression (result_eq_0, arg1_eq_0, arg2_valid_shift, suppressee),
18128
18129            // (r == 0) && ((y >> x) == 0)
18130            new NISuppression(result_eq_0, arg1_shift0_arg2, suppressee),
18131
18132            // (r == 0) && (x >= y) && (y >= 0) && (x valid shift)
18133            // This suppression really ought to have 2**x >= y, but we
18134            // don't have that suppression.  This still might catch a lot of these.
18135            // new NISuppression (result_eq_0, arg1_le_arg2, arg1_ge_0,
18136            //                   arg2_valid_shift, suppressee),
18137          });
18138
18139  // Create a suppression factory for functionBinary
18140
18141}
18142
18143}