truffle: test/compiler/6714694/Tester.java annotate

author	kvn
date	Fri, 20 Jun 2008 10:17:09 -0700
parents
children	c18cbe5936b8

rev	line source
215 273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	1 /*
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	2 * Copyright 2008 Sun Microsystems, Inc. All Rights Reserved.
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	4 *
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	7 * published by the Free Software Foundation.
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	8 *
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	13 * accompanied this code).
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	14 *
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	18 *
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	20 * CA 95054 USA or visit www.sun.com if you need additional information or
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	21 * have any questions.
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	22 */
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	23
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	24 /*
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	25 * @test
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	26 * @bug 6714694
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	27 * @summary assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	28 * @run main/othervm -Xcomp Tester
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	29 */
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	30
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	31 /* Complexity upper bound: 38602 ops */
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	32
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	33 interface Tester_Interface_0 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	34 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	35
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	36
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	37 abstract class Tester_Class_1 implements Tester_Interface_0 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	38 static int var_1 = (false ? (short)'b' : (short)-2.4256387E38F) \| (byte)('g' * -7.660532860983624E307);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	39 float var_2;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	40 byte var_3;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	41 static boolean var_4 = true;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	42 double var_5 = 8.818325751338691E307;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	43 Object var_6;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	44 static short var_7;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	45 final static char var_8 = 'x';
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	46 final static float var_9 = 2.2030989E38F;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	47
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	48
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	49 public Tester_Class_1()
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	50 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	51 var_6 = (var_6 = (var_6 = "xkx"));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	52 switch (var_7 = (var_3 = (byte)var_5))
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	53 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	54 case 113:
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	55
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	56 case 114:
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	57 Object var_12;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	58 var_4 = 4.9121917E37F < 1957795258;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	59 var_4 \|= (var_4 ^= !var_4) ^ (var_4 \|= var_4);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	60 var_3 = (var_3 = (var_3 = (byte)+6010964363045275648L));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	61 break;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	62
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	63 case 102:
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	64
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	65 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	66 final float var_13 = 1.2443151E38F;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	67 var_3 = (byte)(var_1 \|= (var_7 = (var_3 = (byte)var_5)));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	68 var_2 = (long)(var_7 = (var_3 = (byte)var_8)) - (var_7 = (byte)386742565);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	69 var_4 &= var_4;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	70 var_2 = (long)((var_3 = (var_3 = (byte)var_8)) / ((var_4 ^= (var_5 /= var_9) <= (var_1 &= var_1)) ? (var_7 = (short)6872886933545336832L) : (byte)var_8));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	71 var_6 = "uqflj";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	72 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	73 switch (((new String[var_3 = (byte)var_5])[var_3 = (byte)8097442298927900672L]).charAt(1540148550))
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	74 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	75 case 'l':
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	76
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	77 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	78 var_2 = (var_7 = (byte)2.9859440663042714E307);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	79 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	80 Object var_14;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	81 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	82 var_3 = (var_3 = (var_3 = (byte)3.3634427195550136E307));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	83 var_5 += '_';
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	84 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	85 var_6 = "tempfdjen";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	86 var_3 = (((var_4 ^= new String("jmwiwmk").endsWith("rtlstmnuo")) ? !true : !false) ? true : (var_4 = false)) ? (var_3 = (byte)var_5) : (var_3 = (var_3 = (byte)var_5));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	87 var_4 ^= false;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	88 if (1.6435436003809043E307 != var_9)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	89 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	90 boolean var_15 = true;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	91 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	92 else
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	93 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	94 var_4 = false;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	95 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	96 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	97 Object var_16 = ((new Tester_Class_1[(byte)71832757][(byte)1.0694914E38F])[(byte)1315653071][(byte)(var_7 = (var_7 = (byte)var_8))]).var_6 = new int[(byte)var_8][var_3 = (byte)1933656747];
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	98 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	99 var_7 = (var_4 = var_4) ? (short)2.756967E37F : (short)'K';
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	100 byte var_17;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	101 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	102
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	103
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	104
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	105 abstract public Tester_Interface_0 func_0(double[][] arg_0, final Object arg_1);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	106
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	107
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	108 final double func_0(final float arg_0, final short arg_1, final boolean arg_2)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	109 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	110 var_6 = (var_6 = "lmshbl");
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	111 var_3 = (var_3 = (new byte[(new byte[(byte)arg_1])[var_3 = (byte)arg_0]])[var_3 = (var_3 = (byte)(var_1 >>>= var_1))]);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	112 var_5 %= (var_3 = (byte)1909375874);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	113 var_1 /= (char)(short)'i';
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	114 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	115 "vgar".length();
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	116 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	117 int var_10;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	118 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	119 var_3 = (var_4 &= true) ? (byte)(var_5 *= 6375499657746206720L) : (byte)+ (var_5 /= var_9);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	120 var_7 = (var_4 = true) ? (byte)(false ? (short)749593632 : (byte)8.692758043260743E307) : (byte)var_1;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	121 ((new Tester_Class_1[(byte)1.2890904018345944E308])[(byte)var_1]).var_3 = (var_3 = (byte)arg_0);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	122 var_4 = true ^ var_4;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	123 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	124 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	125 var_1 ^= (var_3 = (var_3 = (var_3 = (byte)'U')));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	126 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	127 var_3 = (var_3 = (var_3 = (var_3 = (byte)arg_1)));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	128 char var_11;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	129 var_1 += (var_2 = (var_7 = arg_1));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	130 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	131 var_7 = (var_7 = arg_1);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	132 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	133 var_7 = arg_1;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	134 var_6 = (new char[(byte)1985094111797788672L][var_3 = (byte)3112604683090268160L])[var_3 = (byte)~ (var_3 = (byte)(var_5 += var_1))];
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	135 var_3 = (var_3 = (var_3 = (var_3 = (byte)3694858000202921984L)));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	136 var_1 /= ~ ((byte)1311538336);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	137 (((var_4 \|= arg_2 ? !true && arg_2 : false) ? arg_2 : arg_2) ? "iih".substring(~ (var_3 = (byte)3.5401308E37F), 'g' * arg_1) : "gynskmvoj").trim();
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	138 var_3 = (var_3 = arg_2 ? (byte)+ ~5247392660383928320L : (byte)8392160279007184896L);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	139 var_3 = (var_3 = (var_3 = (byte)var_8));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	140 return (var_5 += 7.157559E37F) + (var_11 = 'V');
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	141 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	142
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	143 public String toString()
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	144 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	145 String result = "[\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	146 result += "Tester_Class_1.var_7 = "; result += Tester.Printer.print(var_7);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	147 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	148 result += "Tester_Class_1.var_3 = "; result += Tester.Printer.print(var_3);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	149 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	150 result += "Tester_Class_1.var_8 = "; result += Tester.Printer.print(var_8);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	151 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	152 result += "Tester_Class_1.var_1 = "; result += Tester.Printer.print(var_1);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	153 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	154 result += "Tester_Class_1.var_4 = "; result += Tester.Printer.print(var_4);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	155 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	156 result += "Tester_Class_1.var_5 = "; result += Tester.Printer.print(var_5);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	157 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	158 result += "Tester_Class_1.var_2 = "; result += Tester.Printer.print(var_2);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	159 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	160 result += "Tester_Class_1.var_9 = "; result += Tester.Printer.print(var_9);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	161 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	162 result += "Tester_Class_1.var_6 = "; result += Tester.Printer.print(var_6);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	163 result += "";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	164 result += "\n]";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	165 return result;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	166 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	167 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	168
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	169
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	170 class Tester_Class_2 extends Tester_Class_1 implements Tester_Interface_0 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	171 final static String var_18 = false \| Tester_Class_1.var_4 \| (Tester_Class_1.var_4 &= (Tester_Class_1.var_4 \|= (Tester_Class_1.var_4 = var_4))) ? "tbobyhqne" : "";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	172 static String var_19 = "acxfj";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	173
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	174
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	175 public Tester_Class_2()
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	176 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	177 Tester_Class_1.var_4 = !Tester_Class_1.var_4;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	178 var_1++;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	179 var_2 = (byte)2.4009747E38F;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	180 new String();
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	181 var_6 = (var_19 = "hsshyw");
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	182 var_19 = var_19;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	183 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	184
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	185
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	186 public Tester_Interface_0 func_0(double[][] arg_0, final Object arg_1)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	187 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	188 var_5 = 4.0352057E37F;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	189 (((false && ! ((Tester_Class_1.var_4 \|= !true) ^ (Tester_Class_1.var_4 ^ false))) ^ (var_4 &= true) ? var_4 : (var_4 ^= true)) ? "spskwj" : "xcqianm").length();
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	190 ((var_4 \|= (Tester_Class_1.var_4 ^= Tester_Class_1.var_4) ? (Tester_Class_1.var_4 &= false) : (Tester_Class_1.var_4 \|= Tester_Class_1.var_4)) ? (Tester_Class_1)(var_6 = new double[(byte)6.628342687109622E307]) : (Tester_Class_1)arg_1).var_6 = arg_0;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	191 var_7 = (short)(byte)(short)8775325134193811456L;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	192 var_4 ^= (var_4 &= !false);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	193 ((Tester_Class_1)arg_1).var_3 = (var_3 = (byte)(var_5 %= 8.933448E37F));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	194 Tester_Class_1 var_20 = Tester_Class_1.var_4 ? (Tester_Class_1)arg_1 : (Tester_Class_1)arg_1;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	195 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	196 var_19.endsWith(var_19);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	197 var_6 = var_20;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	198 (var_20 = (var_20 = var_20)).var_2 = (short)('p' <= 1986176769 % (int)2242661265280256000L % 2664882044098145280L ? ~ (var_3 = (byte)1.1892553447967157E308) & ~1806805036550279168L : (var_7 = (byte)var_8));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	199 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	200 final boolean var_21 = Tester_Class_1.var_4;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	201 var_20.var_3 = (var_3 = (var_20.var_3 = (byte)'t'));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	202 boolean var_22 = true;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	203 Tester_Class_1.var_4 \|= (var_4 = var_21);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	204 var_19 = "ocn";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	205 var_19 = var_19;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	206 var_1 *= Tester_Class_1.var_8;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	207 var_20 = var_22 ? var_20 : var_20;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	208 var_7 = var_21 ? (byte)+ ((byte)var_1) : ((var_20 = (var_20 = var_20)).var_3 = (var_3 = (var_3 = (byte)'L')));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	209 return true ? (var_20 = var_20) : (new Tester_Interface_0[(byte)5618282952859970560L])[var_3 = (byte)Tester_Class_1.var_8];
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	210 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	211
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	212
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	213 public boolean equals(Object obj)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	214 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	215 Tester_Class_1.var_7 = (var_7 = (((Tester_Class_1)obj).var_3 = (byte)var_9));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	216 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	217 final Tester_Class_1 var_23 = (Tester_Class_1)obj;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	218 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	219 ++Tester_Class_1.var_1;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	220 var_5 = (Tester_Class_1.var_7 = var_4 ? (Tester_Class_1.var_7 = (((Tester_Class_1)obj).var_3 = (byte)Tester_Class_1.var_8)) : (var_7 = (byte)var_9));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	221 ((Tester_Class_1)obj).var_6 = var_18.replace(Tester_Class_1.var_8, Tester_Class_1.var_8);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	222 ((new Tester_Class_1[((Tester_Class_1)(obj = new char[var_3 = (byte)Tester_Class_1.var_8])).var_3 = (((Tester_Class_1)obj).var_3 = (byte)(var_1 %= 787509251458841600L))])[(new byte[var_3 = (byte)Tester_Class_1.var_1])[((Tester_Class_1)obj).var_3 = (byte)1.2382548E38F]]).var_3 = (((Tester_Class_1)obj).var_3 = var_4 ? (byte)Tester_Class_1.var_8 : (byte)4.1085164E36F);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	223 var_1 &= var_8;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	224 var_7 = var_4 ? (var_3 = (byte)var_8) : (byte)var_5;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	225 var_19 = var_18;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	226 ("o".compareTo("kwlfk") > (var_2 = 5289241662482067456L) ? (Tester_Class_1)obj : (Tester_Class_1)obj).var_5 -= (((Tester_Class_1)obj).var_3 = (((Tester_Class_1)obj).var_3 = (((Tester_Class_1)obj).var_3 = (byte)var_9)));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	227 return true;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	228 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	229
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	230
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	231 public String toString()
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	232 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	233 String result = "[\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	234 result += "Tester_Class_2.var_7 = "; result += Tester.Printer.print(var_7);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	235 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	236 result += "Tester_Class_2.var_8 = "; result += Tester.Printer.print(var_8);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	237 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	238 result += "Tester_Class_2.var_3 = "; result += Tester.Printer.print(var_3);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	239 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	240 result += "Tester_Class_2.var_18 = "; result += Tester.Printer.print(var_18);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	241 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	242 result += "Tester_Class_2.var_19 = "; result += Tester.Printer.print(var_19);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	243 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	244 result += "Tester_Class_2.var_1 = "; result += Tester.Printer.print(var_1);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	245 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	246 result += "Tester_Class_2.var_4 = "; result += Tester.Printer.print(var_4);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	247 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	248 result += "Tester_Class_2.var_5 = "; result += Tester.Printer.print(var_5);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	249 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	250 result += "Tester_Class_2.var_2 = "; result += Tester.Printer.print(var_2);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	251 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	252 result += "Tester_Class_2.var_9 = "; result += Tester.Printer.print(var_9);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	253 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	254 result += "Tester_Class_2.var_6 = "; result += Tester.Printer.print(var_6);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	255 result += "";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	256 result += "\n]";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	257 return result;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	258 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	259 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	260
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	261
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	262 class Tester_Class_3 extends Tester_Class_2 implements Tester_Interface_0 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	263 long var_24 = 9026266006808413184L;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	264 char var_25;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	265 String var_26 = ((var_4 ^= Tester_Class_1.var_4) ? (!true ? false : (var_4 \|= true)) : (Tester_Class_2.var_4 ^= var_4)) ? "dkmhvhl" : (var_19 = (Tester_Class_2.var_19 = (Tester_Class_2.var_19 = var_18)));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	266 static Tester_Class_2 var_27;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	267 short var_28 = Tester_Class_2.var_7 = (short)(Tester_Class_2.var_1 &= (var_3 = (var_3 = (var_3 = (byte)Tester_Class_2.var_9))));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	268 static boolean var_29 = false;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	269 static Object[][] var_30;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	270 int var_31 = 750583762;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	271 Tester_Class_2 var_32;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	272 final static long var_33 = 3050784555932008448L;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	273
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	274
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	275 public Tester_Class_3()
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	276 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	277 byte[] var_34;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	278 var_4 &= (Tester_Class_1.var_4 = true);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	279 Tester_Class_1.var_1--;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	280 switch (var_28 >>= ~ ((byte)var_28))
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	281 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	282 case 9:
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	283
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	284 case 26:
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	285 Tester_Class_1.var_4 ^= Tester_Class_1.var_4;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	286 (Tester_Class_2.var_19 = "pwtic").indexOf(Tester_Class_2.var_18);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	287 var_26.indexOf(var_19);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	288 ((Tester_Class_1)(new Tester_Interface_0[(byte)var_5])[var_24 <= var_31 ? (byte)'^' : (byte)var_24]).var_2 = 5611775846881101824L;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	289 var_29 \|= (Tester_Class_2.var_4 ^= var_29);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	290 Tester_Class_2 var_35;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	291 var_24 <<= (var_31 >>= (var_25 = var_8));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	292 break;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	293
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	294 case 28:
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	295
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	296 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	297 new String();
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	298 var_5 %= (var_25 = 'n');
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	299 ((Tester_Class_2)(Tester_Class_1)(((Tester_Class_1)(var_6 = Tester_Class_2.var_18)).var_6 = (var_26 = ""))).var_2 = var_31;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	300 --var_1;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	301 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	302
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	303
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	304
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	305
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	306 public String toString()
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	307 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	308 String result = "[\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	309 result += "Tester_Class_3.var_8 = "; result += Tester.Printer.print(var_8);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	310 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	311 result += "Tester_Class_3.var_25 = "; result += Tester.Printer.print(var_25);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	312 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	313 result += "Tester_Class_3.var_1 = "; result += Tester.Printer.print(var_1);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	314 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	315 result += "Tester_Class_3.var_31 = "; result += Tester.Printer.print(var_31);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	316 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	317 result += "Tester_Class_3.var_30 = "; result += Tester.Printer.print(var_30);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	318 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	319 result += "Tester_Class_3.var_24 = "; result += Tester.Printer.print(var_24);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	320 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	321 result += "Tester_Class_3.var_33 = "; result += Tester.Printer.print(var_33);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	322 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	323 result += "Tester_Class_3.var_5 = "; result += Tester.Printer.print(var_5);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	324 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	325 result += "Tester_Class_3.var_2 = "; result += Tester.Printer.print(var_2);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	326 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	327 result += "Tester_Class_3.var_9 = "; result += Tester.Printer.print(var_9);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	328 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	329 result += "Tester_Class_3.var_7 = "; result += Tester.Printer.print(var_7);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	330 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	331 result += "Tester_Class_3.var_28 = "; result += Tester.Printer.print(var_28);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	332 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	333 result += "Tester_Class_3.var_3 = "; result += Tester.Printer.print(var_3);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	334 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	335 result += "Tester_Class_3.var_18 = "; result += Tester.Printer.print(var_18);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	336 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	337 result += "Tester_Class_3.var_19 = "; result += Tester.Printer.print(var_19);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	338 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	339 result += "Tester_Class_3.var_26 = "; result += Tester.Printer.print(var_26);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	340 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	341 result += "Tester_Class_3.var_4 = "; result += Tester.Printer.print(var_4);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	342 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	343 result += "Tester_Class_3.var_29 = "; result += Tester.Printer.print(var_29);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	344 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	345 result += "Tester_Class_3.var_27 = "; result += Tester.Printer.print(var_27);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	346 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	347 result += "Tester_Class_3.var_32 = "; result += Tester.Printer.print(var_32);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	348 result += "\n";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	349 result += "Tester_Class_3.var_6 = "; result += Tester.Printer.print(var_6);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	350 result += "";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	351 result += "\n]";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	352 return result;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	353 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	354 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	355
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	356 public class Tester {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	357 static double var_36 = 2.679028326789642E307;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	358 float var_37;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	359 String var_38 = Tester_Class_2.var_18;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	360 static Tester_Interface_0 var_39;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	361 static char var_40 = 'D';
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	362 Tester_Class_1 var_41;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	363 static int var_42;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	364 final static boolean var_43 = false;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	365
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	366
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	367 final static Tester_Class_2 func_0(Tester_Class_1 arg_0, final Tester_Class_2 arg_1)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	368 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	369 "ooots".replaceFirst("rdxor", ((new Tester_Class_3[arg_1.var_3 = (byte)2.7836305E38F])[arg_0.var_3 = (byte)+ + +1.4958218616334936E307]).var_26);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	370 if (true)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	371 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	372 arg_0 = (Tester_Class_3)arg_0;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	373 ((Tester_Class_3)arg_0).var_25 = var_40;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	374 final Tester_Class_2 var_44 = (Tester_Class_2)((Tester_Class_3.var_29 \|= var_43) ? arg_0 : (arg_0.var_6 = Tester_Class_3.var_18));
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	375 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	376 else
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	377 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	378 var_39 = (Tester_Class_3.var_27 = (Tester_Class_3)arg_1);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	379 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	380 Tester_Class_3.var_19 = "onndgsil";
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	381 var_39 = arg_0;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	382 return (Tester_Class_2.var_4 &= Tester_Class_2.var_4 ^ true) ? (((Tester_Class_3)arg_0).var_32 = (Tester_Class_3)arg_1) : (((Tester_Class_3)arg_0).var_32 = (Tester_Class_3)arg_1);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	383 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	384
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	385 private final static float func_1(final short arg_0, int[][] arg_1, final long arg_2)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	386 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	387 Tester_Class_2.var_1 *= arg_0;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	388 double var_45 = 6.841391103184752E307;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	389 long var_46;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	390 Tester_Class_2.var_1--;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	391 --var_40;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	392 ++var_40;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	393 ++Tester_Class_3.var_1;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	394 Tester_Class_1.var_4 = false;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	395 var_36 %= 'X';
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	396 ++Tester_Class_2.var_1;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	397 Tester_Class_1.var_1++;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	398 return 3.2422038E38F;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	399 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	400
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	401 private final static char func_2(double arg_0, final byte arg_1, int arg_2)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	402 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	403 --Tester_Class_3.var_1;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	404 if (Tester_Class_1.var_4)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	405 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	406 if (var_43)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	407 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	408 Tester_Class_3.var_1++;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	409 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	410 else
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	411 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	412 var_40 <<= 1329560515532651520L;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	413 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	414 (false & Tester_Class_2.var_4 ? (new Tester_Class_1[arg_1])[arg_1] : (new Tester_Class_1[arg_1][arg_1])[arg_1][arg_1]).var_3 = arg_1;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	415 Tester_Class_2.var_19 = Tester_Class_3.var_19;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	416 --var_40;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	417 final long var_47 = ~Tester_Class_3.var_33 << var_40--;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	418 ((Tester_Class_3)(new Tester_Class_2[arg_1][arg_1])[arg_1][arg_1]).var_24 = (var_36 = (long)arg_1 * ~arg_1);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	419 Tester_Class_2.var_19 = Tester_Class_2.var_19;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	420 ++((new Tester_Class_3[arg_1])[arg_1]).var_24;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	421 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	422 else
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	423 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	424 var_40++;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	425 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	426 var_40 <<= var_40;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	427 if (true)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	428 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	429 ++arg_2;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	430 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	431 else
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	432 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	433 Tester_Class_2.var_7 = arg_1;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	434 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	435 boolean var_48 = true;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	436 var_36 /= arg_1;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	437 final short var_49 = 15276;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	438 Tester_Interface_0 var_50;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	439 ((Tester_Class_2.var_19 = (Tester_Class_2.var_19 = Tester_Class_2.var_19)) + "xhi").toString();
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	440 arg_2++;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	441 return var_40;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	442 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	443
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	444 public final static char func_4(final boolean arg_0)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	445 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	446 float var_52 = 2.8063675E38F;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	447 var_40--;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	448 Object var_53;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	449 Tester_Class_3.var_29 \|= (Tester_Class_3.var_29 &= true);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	450 if (!Tester_Class_1.var_4)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	451 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	452 --var_40;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	453 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	454 else
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	455 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	456 var_52 %= 2027756834;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	457 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	458 int var_54 = Tester_Class_1.var_1++;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	459 var_40--;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	460 long var_55;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	461 byte var_56 = 97;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	462 var_36 *= 9.75628909363086E307 % + -1.9812653793936264E306;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	463 int var_57;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	464 boolean var_58 = Tester_Class_1.var_4 ^= var_43;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	465 return 'J';
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	466 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	467
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	468 static float func_5(final Object arg_0, float arg_1, final Tester_Class_2 arg_2)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	469 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	470 var_39 = arg_2;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	471 Tester_Class_3.var_27 = arg_2;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	472 arg_1 %= 1.7777554E38F;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	473 var_39 = (Tester_Class_3.var_27 = arg_2);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	474 Tester_Class_3 var_59;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	475 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	476 var_40 -= arg_1 - ~ (((Tester_Class_3)arg_2).var_3 = (byte)1455854212);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	477 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	478 Object var_60 = Tester_Class_1.var_4 ? arg_0 : new String[arg_2.var_3 = (byte)arg_1][(byte)((Tester_Class_3)arg_0).var_28];
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	479 Tester_Class_3.var_27 = (Tester_Class_2)(var_39 = arg_2);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	480 ((Tester_Class_3.var_4 \|= var_43) ? (var_59 = (var_59 = (var_59 = (Tester_Class_3)var_60))) : (var_59 = (Tester_Class_3)arg_2)).var_24 ^= Tester_Class_3.var_1;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	481 return Tester_Class_1.var_9;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	482 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	483
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	484 private static void func_6(char arg_0, final Tester_Class_3 arg_1, String arg_2, final double arg_3)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	485 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	486 ((new Tester_Class_1[(byte)arg_1.var_28])[(arg_1.var_32 = arg_1).var_3 = (byte)var_40]).var_2 = Tester_Class_3.var_9;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	487 double var_61;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	488 (true ? (arg_1.var_32 = arg_1) : (arg_1.var_32 = (Tester_Class_3.var_27 = (arg_1.var_32 = arg_1)))).var_6 = var_43 \| (Tester_Class_2.var_4 = !Tester_Class_3.var_4) ? (arg_1.var_26 = arg_2) : (Tester_Class_2.var_19 = Tester_Class_2.var_18);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	489 }
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	490
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	491 private final char func_7(int arg_0)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	492 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	493 Tester_Class_2.var_4 &= var_43;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	494 float var_62 = Tester_Class_3.var_9;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	495 --var_40;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	496 int var_63 = Tester_Class_1.var_1++;
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	497 {
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	498 "nncjfoit".indexOf((new int[(byte)'\\'])[(byte)var_36]);
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	499 if (var_43)
273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs kvn parents: diff changeset	500 {

215

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

1 /*

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

4 *

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

5 * This code is free software; you can redistribute it and/or modify it

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

6 * under the terms of the GNU General Public License version 2 only, as

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

7 * published by the Free Software Foundation.

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

8 *

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

9 * This code is distributed in the hope that it will be useful, but WITHOUT

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

12 * version 2 for more details (a copy is included in the LICENSE file that

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

13 * accompanied this code).

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

14 *

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

15 * You should have received a copy of the GNU General Public License version

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

16 * 2 along with this work; if not, write to the Free Software Foundation,

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

18 *

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

20 * CA 95054 USA or visit www.sun.com if you need additional information or

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

21 * have any questions.

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

22 */

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

23

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

24 /*

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

25 * @test

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

26 * @bug 6714694

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

27 * @summary assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

28 * @run main/othervm -Xcomp Tester

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

29 */

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

30

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

31 /* Complexity upper bound: 38602 ops */

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

32

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

33 interface Tester_Interface_0 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

34 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

35

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

36

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

37 abstract class Tester_Class_1 implements Tester_Interface_0 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

38 static int var_1 = (false ? (short)'b' : (short)-2.4256387E38F) | (byte)('g' * -7.660532860983624E307);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

39 float var_2;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

40 byte var_3;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

41 static boolean var_4 = true;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

42 double var_5 = 8.818325751338691E307;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

43 Object var_6;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

44 static short var_7;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

45 final static char var_8 = 'x';

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

46 final static float var_9 = 2.2030989E38F;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

47

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

48

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

49 public Tester_Class_1()

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

50 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

51 var_6 = (var_6 = (var_6 = "xkx"));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

52 switch (var_7 = (var_3 = (byte)var_5))

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

53 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

54 case 113:

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

55

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

56 case 114:

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

57 Object var_12;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

58 var_4 = 4.9121917E37F < 1957795258;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

59 var_4 |= (var_4 ^= !var_4) ^ (var_4 |= var_4);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

60 var_3 = (var_3 = (var_3 = (byte)+6010964363045275648L));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

61 break;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

62

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

63 case 102:

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

64

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

65 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

66 final float var_13 = 1.2443151E38F;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

67 var_3 = (byte)(var_1 |= (var_7 = (var_3 = (byte)var_5)));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

68 var_2 = (long)(var_7 = (var_3 = (byte)var_8)) - (var_7 = (byte)386742565);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

69 var_4 &= var_4;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

70 var_2 = (long)((var_3 = (var_3 = (byte)var_8)) / ((var_4 ^= (var_5 /= var_9) <= (var_1 &= var_1)) ? (var_7 = (short)6872886933545336832L) : (byte)var_8));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

71 var_6 = "uqflj";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

72 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

73 switch (((new String[var_3 = (byte)var_5])[var_3 = (byte)8097442298927900672L]).charAt(1540148550))

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

74 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

75 case 'l':

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

76

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

77 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

78 var_2 = (var_7 = (byte)2.9859440663042714E307);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

79 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

80 Object var_14;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

81 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

82 var_3 = (var_3 = (var_3 = (byte)3.3634427195550136E307));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

83 var_5 += '_';

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

84 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

85 var_6 = "tempfdjen";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

86 var_3 = (((var_4 ^= new String("jmwiwmk").endsWith("rtlstmnuo")) ? !true : !false) ? true : (var_4 = false)) ? (var_3 = (byte)var_5) : (var_3 = (var_3 = (byte)var_5));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

87 var_4 ^= false;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

88 if (1.6435436003809043E307 != var_9)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

89 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

90 boolean var_15 = true;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

91 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

92 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

93 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

94 var_4 = false;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

95 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

96 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

97 Object var_16 = ((new Tester_Class_1[(byte)71832757][(byte)1.0694914E38F])[(byte)1315653071][(byte)(var_7 = (var_7 = (byte)var_8))]).var_6 = new int[(byte)var_8][var_3 = (byte)1933656747];

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

98 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

99 var_7 = (var_4 = var_4) ? (short)2.756967E37F : (short)'K';

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

100 byte var_17;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

101 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

102

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

103

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

104

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

105 abstract public Tester_Interface_0 func_0(double[][] arg_0, final Object arg_1);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

106

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

107

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

108 final double func_0(final float arg_0, final short arg_1, final boolean arg_2)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

109 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

110 var_6 = (var_6 = "lmshbl");

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

111 var_3 = (var_3 = (new byte[(new byte[(byte)arg_1])[var_3 = (byte)arg_0]])[var_3 = (var_3 = (byte)(var_1 >>>= var_1))]);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

112 var_5 %= (var_3 = (byte)1909375874);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

113 var_1 /= (char)(short)'i';

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

114 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

115 "vgar".length();

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

116 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

117 int var_10;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

118 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

119 var_3 = (var_4 &= true) ? (byte)(var_5 *= 6375499657746206720L) : (byte)+ (var_5 /= var_9);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

120 var_7 = (var_4 = true) ? (byte)(false ? (short)749593632 : (byte)8.692758043260743E307) : (byte)var_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

121 ((new Tester_Class_1[(byte)1.2890904018345944E308])[(byte)var_1]).var_3 = (var_3 = (byte)arg_0);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

122 var_4 = true ^ var_4;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

123 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

124 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

125 var_1 ^= (var_3 = (var_3 = (var_3 = (byte)'U')));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

126 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

127 var_3 = (var_3 = (var_3 = (var_3 = (byte)arg_1)));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

128 char var_11;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

129 var_1 += (var_2 = (var_7 = arg_1));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

130 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

131 var_7 = (var_7 = arg_1);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

132 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

133 var_7 = arg_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

134 var_6 = (new char[(byte)1985094111797788672L][var_3 = (byte)3112604683090268160L])[var_3 = (byte)~ (var_3 = (byte)(var_5 += var_1))];

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

135 var_3 = (var_3 = (var_3 = (var_3 = (byte)3694858000202921984L)));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

136 var_1 /= ~ ((byte)1311538336);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

137 (((var_4 |= arg_2 ? !true && arg_2 : false) ? arg_2 : arg_2) ? "iih".substring(~ (var_3 = (byte)3.5401308E37F), 'g' * arg_1) : "gynskmvoj").trim();

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

138 var_3 = (var_3 = arg_2 ? (byte)+ ~5247392660383928320L : (byte)8392160279007184896L);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

139 var_3 = (var_3 = (var_3 = (byte)var_8));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

140 return (var_5 += 7.157559E37F) + (var_11 = 'V');

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

141 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

142

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

143 public String toString()

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

144 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

145 String result = "[\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

146 result += "Tester_Class_1.var_7 = "; result += Tester.Printer.print(var_7);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

147 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

148 result += "Tester_Class_1.var_3 = "; result += Tester.Printer.print(var_3);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

149 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

150 result += "Tester_Class_1.var_8 = "; result += Tester.Printer.print(var_8);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

151 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

152 result += "Tester_Class_1.var_1 = "; result += Tester.Printer.print(var_1);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

153 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

154 result += "Tester_Class_1.var_4 = "; result += Tester.Printer.print(var_4);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

155 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

156 result += "Tester_Class_1.var_5 = "; result += Tester.Printer.print(var_5);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

157 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

158 result += "Tester_Class_1.var_2 = "; result += Tester.Printer.print(var_2);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

159 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

160 result += "Tester_Class_1.var_9 = "; result += Tester.Printer.print(var_9);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

161 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

162 result += "Tester_Class_1.var_6 = "; result += Tester.Printer.print(var_6);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

163 result += "";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

164 result += "\n]";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

165 return result;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

166 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

167 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

168

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

169

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

170 class Tester_Class_2 extends Tester_Class_1 implements Tester_Interface_0 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

171 final static String var_18 = false | Tester_Class_1.var_4 | (Tester_Class_1.var_4 &= (Tester_Class_1.var_4 |= (Tester_Class_1.var_4 = var_4))) ? "tbobyhqne" : "";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

172 static String var_19 = "acxfj";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

173

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

174

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

175 public Tester_Class_2()

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

176 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

177 Tester_Class_1.var_4 = !Tester_Class_1.var_4;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

178 var_1++;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

179 var_2 = (byte)2.4009747E38F;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

180 new String();

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

181 var_6 = (var_19 = "hsshyw");

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

182 var_19 = var_19;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

183 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

184

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

185

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

186 public Tester_Interface_0 func_0(double[][] arg_0, final Object arg_1)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

187 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

188 var_5 = 4.0352057E37F;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

189 (((false && ! ((Tester_Class_1.var_4 |= !true) ^ (Tester_Class_1.var_4 ^ false))) ^ (var_4 &= true) ? var_4 : (var_4 ^= true)) ? "spskwj" : "xcqianm").length();

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

190 ((var_4 |= (Tester_Class_1.var_4 ^= Tester_Class_1.var_4) ? (Tester_Class_1.var_4 &= false) : (Tester_Class_1.var_4 |= Tester_Class_1.var_4)) ? (Tester_Class_1)(var_6 = new double[(byte)6.628342687109622E307]) : (Tester_Class_1)arg_1).var_6 = arg_0;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

191 var_7 = (short)(byte)(short)8775325134193811456L;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

192 var_4 ^= (var_4 &= !false);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

193 ((Tester_Class_1)arg_1).var_3 = (var_3 = (byte)(var_5 %= 8.933448E37F));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

194 Tester_Class_1 var_20 = Tester_Class_1.var_4 ? (Tester_Class_1)arg_1 : (Tester_Class_1)arg_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

195 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

196 var_19.endsWith(var_19);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

197 var_6 = var_20;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

198 (var_20 = (var_20 = var_20)).var_2 = (short)('p' <= 1986176769 % (int)2242661265280256000L % 2664882044098145280L ? ~ (var_3 = (byte)1.1892553447967157E308) & ~1806805036550279168L : (var_7 = (byte)var_8));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

199 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

200 final boolean var_21 = Tester_Class_1.var_4;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

201 var_20.var_3 = (var_3 = (var_20.var_3 = (byte)'t'));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

202 boolean var_22 = true;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

203 Tester_Class_1.var_4 |= (var_4 = var_21);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

204 var_19 = "ocn";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

205 var_19 = var_19;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

206 var_1 *= Tester_Class_1.var_8;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

207 var_20 = var_22 ? var_20 : var_20;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

208 var_7 = var_21 ? (byte)+ ((byte)var_1) : ((var_20 = (var_20 = var_20)).var_3 = (var_3 = (var_3 = (byte)'L')));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

209 return true ? (var_20 = var_20) : (new Tester_Interface_0[(byte)5618282952859970560L])[var_3 = (byte)Tester_Class_1.var_8];

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

210 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

211

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

212

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

213 public boolean equals(Object obj)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

214 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

215 Tester_Class_1.var_7 = (var_7 = (((Tester_Class_1)obj).var_3 = (byte)var_9));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

216 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

217 final Tester_Class_1 var_23 = (Tester_Class_1)obj;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

218 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

219 ++Tester_Class_1.var_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

220 var_5 = (Tester_Class_1.var_7 = var_4 ? (Tester_Class_1.var_7 = (((Tester_Class_1)obj).var_3 = (byte)Tester_Class_1.var_8)) : (var_7 = (byte)var_9));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

221 ((Tester_Class_1)obj).var_6 = var_18.replace(Tester_Class_1.var_8, Tester_Class_1.var_8);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

222 ((new Tester_Class_1[((Tester_Class_1)(obj = new char[var_3 = (byte)Tester_Class_1.var_8])).var_3 = (((Tester_Class_1)obj).var_3 = (byte)(var_1 %= 787509251458841600L))])[(new byte[var_3 = (byte)Tester_Class_1.var_1])[((Tester_Class_1)obj).var_3 = (byte)1.2382548E38F]]).var_3 = (((Tester_Class_1)obj).var_3 = var_4 ? (byte)Tester_Class_1.var_8 : (byte)4.1085164E36F);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

223 var_1 &= var_8;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

224 var_7 = var_4 ? (var_3 = (byte)var_8) : (byte)var_5;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

225 var_19 = var_18;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

226 ("o".compareTo("kwlfk") > (var_2 = 5289241662482067456L) ? (Tester_Class_1)obj : (Tester_Class_1)obj).var_5 -= (((Tester_Class_1)obj).var_3 = (((Tester_Class_1)obj).var_3 = (((Tester_Class_1)obj).var_3 = (byte)var_9)));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

227 return true;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

228 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

229

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

230

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

231 public String toString()

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

232 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

233 String result = "[\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

234 result += "Tester_Class_2.var_7 = "; result += Tester.Printer.print(var_7);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

235 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

236 result += "Tester_Class_2.var_8 = "; result += Tester.Printer.print(var_8);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

237 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

238 result += "Tester_Class_2.var_3 = "; result += Tester.Printer.print(var_3);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

239 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

240 result += "Tester_Class_2.var_18 = "; result += Tester.Printer.print(var_18);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

241 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

242 result += "Tester_Class_2.var_19 = "; result += Tester.Printer.print(var_19);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

243 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

244 result += "Tester_Class_2.var_1 = "; result += Tester.Printer.print(var_1);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

245 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

246 result += "Tester_Class_2.var_4 = "; result += Tester.Printer.print(var_4);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

247 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

248 result += "Tester_Class_2.var_5 = "; result += Tester.Printer.print(var_5);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

249 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

250 result += "Tester_Class_2.var_2 = "; result += Tester.Printer.print(var_2);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

251 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

252 result += "Tester_Class_2.var_9 = "; result += Tester.Printer.print(var_9);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

253 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

254 result += "Tester_Class_2.var_6 = "; result += Tester.Printer.print(var_6);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

255 result += "";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

256 result += "\n]";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

257 return result;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

258 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

259 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

260

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

261

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

262 class Tester_Class_3 extends Tester_Class_2 implements Tester_Interface_0 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

263 long var_24 = 9026266006808413184L;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

264 char var_25;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

265 String var_26 = ((var_4 ^= Tester_Class_1.var_4) ? (!true ? false : (var_4 |= true)) : (Tester_Class_2.var_4 ^= var_4)) ? "dkmhvhl" : (var_19 = (Tester_Class_2.var_19 = (Tester_Class_2.var_19 = var_18)));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

266 static Tester_Class_2 var_27;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

267 short var_28 = Tester_Class_2.var_7 = (short)(Tester_Class_2.var_1 &= (var_3 = (var_3 = (var_3 = (byte)Tester_Class_2.var_9))));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

268 static boolean var_29 = false;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

269 static Object[][] var_30;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

270 int var_31 = 750583762;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

271 Tester_Class_2 var_32;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

272 final static long var_33 = 3050784555932008448L;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

273

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

274

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

275 public Tester_Class_3()

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

276 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

277 byte[] var_34;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

278 var_4 &= (Tester_Class_1.var_4 = true);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

279 Tester_Class_1.var_1--;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

280 switch (var_28 >>= ~ ((byte)var_28))

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

281 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

282 case 9:

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

283

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

284 case 26:

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

285 Tester_Class_1.var_4 ^= Tester_Class_1.var_4;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

286 (Tester_Class_2.var_19 = "pwtic").indexOf(Tester_Class_2.var_18);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

287 var_26.indexOf(var_19);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

288 ((Tester_Class_1)(new Tester_Interface_0[(byte)var_5])[var_24 <= var_31 ? (byte)'^' : (byte)var_24]).var_2 = 5611775846881101824L;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

289 var_29 |= (Tester_Class_2.var_4 ^= var_29);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

290 Tester_Class_2 var_35;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

291 var_24 <<= (var_31 >>= (var_25 = var_8));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

292 break;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

293

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

294 case 28:

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

295

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

296 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

297 new String();

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

298 var_5 %= (var_25 = 'n');

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

299 ((Tester_Class_2)(Tester_Class_1)(((Tester_Class_1)(var_6 = Tester_Class_2.var_18)).var_6 = (var_26 = ""))).var_2 = var_31;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

300 --var_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

301 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

302

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

303

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

304

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

305

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

306 public String toString()

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

307 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

308 String result = "[\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

309 result += "Tester_Class_3.var_8 = "; result += Tester.Printer.print(var_8);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

310 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

311 result += "Tester_Class_3.var_25 = "; result += Tester.Printer.print(var_25);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

312 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

313 result += "Tester_Class_3.var_1 = "; result += Tester.Printer.print(var_1);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

314 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

315 result += "Tester_Class_3.var_31 = "; result += Tester.Printer.print(var_31);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

316 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

317 result += "Tester_Class_3.var_30 = "; result += Tester.Printer.print(var_30);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

318 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

319 result += "Tester_Class_3.var_24 = "; result += Tester.Printer.print(var_24);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

320 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

321 result += "Tester_Class_3.var_33 = "; result += Tester.Printer.print(var_33);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

322 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

323 result += "Tester_Class_3.var_5 = "; result += Tester.Printer.print(var_5);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

324 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

325 result += "Tester_Class_3.var_2 = "; result += Tester.Printer.print(var_2);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

326 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

327 result += "Tester_Class_3.var_9 = "; result += Tester.Printer.print(var_9);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

328 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

329 result += "Tester_Class_3.var_7 = "; result += Tester.Printer.print(var_7);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

330 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

331 result += "Tester_Class_3.var_28 = "; result += Tester.Printer.print(var_28);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

332 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

333 result += "Tester_Class_3.var_3 = "; result += Tester.Printer.print(var_3);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

334 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

335 result += "Tester_Class_3.var_18 = "; result += Tester.Printer.print(var_18);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

336 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

337 result += "Tester_Class_3.var_19 = "; result += Tester.Printer.print(var_19);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

338 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

339 result += "Tester_Class_3.var_26 = "; result += Tester.Printer.print(var_26);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

340 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

341 result += "Tester_Class_3.var_4 = "; result += Tester.Printer.print(var_4);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

342 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

343 result += "Tester_Class_3.var_29 = "; result += Tester.Printer.print(var_29);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

344 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

345 result += "Tester_Class_3.var_27 = "; result += Tester.Printer.print(var_27);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

346 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

347 result += "Tester_Class_3.var_32 = "; result += Tester.Printer.print(var_32);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

348 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

349 result += "Tester_Class_3.var_6 = "; result += Tester.Printer.print(var_6);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

350 result += "";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

351 result += "\n]";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

352 return result;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

353 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

354 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

355

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

356 public class Tester {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

357 static double var_36 = 2.679028326789642E307;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

358 float var_37;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

359 String var_38 = Tester_Class_2.var_18;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

360 static Tester_Interface_0 var_39;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

361 static char var_40 = 'D';

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

362 Tester_Class_1 var_41;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

363 static int var_42;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

364 final static boolean var_43 = false;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

365

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

366

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

367 final static Tester_Class_2 func_0(Tester_Class_1 arg_0, final Tester_Class_2 arg_1)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

368 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

369 "ooots".replaceFirst("rdxor", ((new Tester_Class_3[arg_1.var_3 = (byte)2.7836305E38F])[arg_0.var_3 = (byte)+ + +1.4958218616334936E307]).var_26);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

370 if (true)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

371 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

372 arg_0 = (Tester_Class_3)arg_0;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

373 ((Tester_Class_3)arg_0).var_25 = var_40;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

374 final Tester_Class_2 var_44 = (Tester_Class_2)((Tester_Class_3.var_29 |= var_43) ? arg_0 : (arg_0.var_6 = Tester_Class_3.var_18));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

375 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

376 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

377 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

378 var_39 = (Tester_Class_3.var_27 = (Tester_Class_3)arg_1);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

379 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

380 Tester_Class_3.var_19 = "onndgsil";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

381 var_39 = arg_0;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

382 return (Tester_Class_2.var_4 &= Tester_Class_2.var_4 ^ true) ? (((Tester_Class_3)arg_0).var_32 = (Tester_Class_3)arg_1) : (((Tester_Class_3)arg_0).var_32 = (Tester_Class_3)arg_1);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

383 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

384

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

385 private final static float func_1(final short arg_0, int[][] arg_1, final long arg_2)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

386 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

387 Tester_Class_2.var_1 *= arg_0;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

388 double var_45 = 6.841391103184752E307;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

389 long var_46;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

390 Tester_Class_2.var_1--;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

391 --var_40;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

392 ++var_40;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

393 ++Tester_Class_3.var_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

394 Tester_Class_1.var_4 = false;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

395 var_36 %= 'X';

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

396 ++Tester_Class_2.var_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

397 Tester_Class_1.var_1++;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

398 return 3.2422038E38F;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

399 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

400

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

401 private final static char func_2(double arg_0, final byte arg_1, int arg_2)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

402 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

403 --Tester_Class_3.var_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

404 if (Tester_Class_1.var_4)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

405 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

406 if (var_43)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

407 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

408 Tester_Class_3.var_1++;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

409 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

410 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

411 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

412 var_40 <<= 1329560515532651520L;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

413 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

414 (false & Tester_Class_2.var_4 ? (new Tester_Class_1[arg_1])[arg_1] : (new Tester_Class_1[arg_1][arg_1])[arg_1][arg_1]).var_3 = arg_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

415 Tester_Class_2.var_19 = Tester_Class_3.var_19;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

416 --var_40;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

417 final long var_47 = ~Tester_Class_3.var_33 << var_40--;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

418 ((Tester_Class_3)(new Tester_Class_2[arg_1][arg_1])[arg_1][arg_1]).var_24 *= (var_36 *= (long)arg_1 * ~arg_1);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

419 Tester_Class_2.var_19 = Tester_Class_2.var_19;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

420 ++((new Tester_Class_3[arg_1])[arg_1]).var_24;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

421 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

422 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

423 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

424 var_40++;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

425 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

426 var_40 <<= var_40;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

427 if (true)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

428 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

429 ++arg_2;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

430 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

431 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

432 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

433 Tester_Class_2.var_7 = arg_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

434 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

435 boolean var_48 = true;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

436 var_36 /= arg_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

437 final short var_49 = 15276;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

438 Tester_Interface_0 var_50;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

439 ((Tester_Class_2.var_19 = (Tester_Class_2.var_19 = Tester_Class_2.var_19)) + "xhi").toString();

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

440 arg_2++;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

441 return var_40;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

442 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

443

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

444 public final static char func_4(final boolean arg_0)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

445 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

446 float var_52 = 2.8063675E38F;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

447 var_40--;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

448 Object var_53;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

449 Tester_Class_3.var_29 |= (Tester_Class_3.var_29 &= true);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

450 if (!Tester_Class_1.var_4)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

451 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

452 --var_40;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

453 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

454 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

455 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

456 var_52 %= 2027756834;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

457 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

458 int var_54 = Tester_Class_1.var_1++;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

459 var_40--;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

460 long var_55;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

461 byte var_56 = 97;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

462 var_36 *= 9.75628909363086E307 % + -1.9812653793936264E306;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

463 int var_57;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

464 boolean var_58 = Tester_Class_1.var_4 ^= var_43;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

465 return 'J';

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

466 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

467

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

468 static float func_5(final Object arg_0, float arg_1, final Tester_Class_2 arg_2)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

469 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

470 var_39 = arg_2;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

471 Tester_Class_3.var_27 = arg_2;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

472 arg_1 %= 1.7777554E38F;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

473 var_39 = (Tester_Class_3.var_27 = arg_2);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

474 Tester_Class_3 var_59;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

475 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

476 var_40 -= arg_1 - ~ (((Tester_Class_3)arg_2).var_3 = (byte)1455854212);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

477 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

478 Object var_60 = Tester_Class_1.var_4 ? arg_0 : new String[arg_2.var_3 = (byte)arg_1][(byte)((Tester_Class_3)arg_0).var_28];

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

479 Tester_Class_3.var_27 = (Tester_Class_2)(var_39 = arg_2);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

480 ((Tester_Class_3.var_4 |= var_43) ? (var_59 = (var_59 = (var_59 = (Tester_Class_3)var_60))) : (var_59 = (Tester_Class_3)arg_2)).var_24 ^= Tester_Class_3.var_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

481 return Tester_Class_1.var_9;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

482 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

483

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

484 private static void func_6(char arg_0, final Tester_Class_3 arg_1, String arg_2, final double arg_3)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

485 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

486 ((new Tester_Class_1[(byte)arg_1.var_28])[(arg_1.var_32 = arg_1).var_3 = (byte)var_40]).var_2 = Tester_Class_3.var_9;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

487 double var_61;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

488 (true ? (arg_1.var_32 = arg_1) : (arg_1.var_32 = (Tester_Class_3.var_27 = (arg_1.var_32 = arg_1)))).var_6 = var_43 | (Tester_Class_2.var_4 = !Tester_Class_3.var_4) ? (arg_1.var_26 = arg_2) : (Tester_Class_2.var_19 = Tester_Class_2.var_18);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

489 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

490

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

491 private final char func_7(int arg_0)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

492 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

493 Tester_Class_2.var_4 &= var_43;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

494 float var_62 = Tester_Class_3.var_9;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

495 --var_40;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

496 int var_63 = Tester_Class_1.var_1++;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

497 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

498 "nncjfoit".indexOf((new int[(byte)'\\'])[(byte)var_36]);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

499 if (var_43)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

500 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

501 ((new Tester_Class_3[(byte)var_40][(byte)Tester_Class_2.var_1])[(byte)5046997225818337280L][(byte)var_63]).var_24 >>>= var_40;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

502 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

503 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

504 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

505 --var_40;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

506 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

507 --Tester_Class_2.var_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

508 --var_63;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

509 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

510 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

511 final byte var_64 = Tester_Class_1.var_4 ? (byte)'M' : (byte)(var_62 -= + ((byte)Tester_Class_1.var_8));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

512 float var_65;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

513 var_62 *= ((Tester_Class_3)(new Tester_Interface_0[var_64])[var_64]).var_24++;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

514 var_36 /= var_64;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

515 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

516 double var_66;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

517 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

518 var_40 += 3500240160155094016L;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

519 ((new Tester_Class_1[var_64][var_64])[var_64][var_64]).var_3 = (byte)(Tester_Class_2.var_7 = (Tester_Class_1.var_7 = (Tester_Class_1.var_7 = (Tester_Class_1.var_7 = var_64))));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

520 ++Tester_Class_3.var_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

521 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

522 --arg_0;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

523 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

524 arg_0++;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

525 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

526 Tester_Class_2.var_1++;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

527 var_40 &= (short)((byte)Tester_Class_2.var_8 >> (((new Tester_Class_3[(byte)var_36])[(byte)(var_40 = Tester_Class_3.var_8)]).var_3 = (byte)((byte)3.3531374E38F * var_40)));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

528 var_36 %= (var_62 = (byte)900943133);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

529 var_36 = Tester_Class_3.var_33;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

530 var_62 += (var_40 /= (byte)6766658341842315264L % (byte)'p') * (short)2019461672;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

531 --var_40;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

532 if (true)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

533 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

534 var_62 *= 365879806965555200L;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

535 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

536 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

537 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

538 var_36 -= ~9163555887358003200L;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

539 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

540 Tester_Class_1.var_4 = Tester_Class_1.var_4;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

541 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

542 var_40 <<= var_63;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

543 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

544 var_40++;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

545 String var_67;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

546 return Tester_Class_1.var_8;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

547 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

548

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

549 private final static Tester_Interface_0 func_8(char arg_0, final Tester_Class_2 arg_1, final String arg_2)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

550 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

551 ((new Tester[(byte)((Tester_Class_3)arg_1).var_28])[((Tester_Class_1)(var_39 = arg_1)).var_3 = ((Tester_Class_3.var_27 = (Tester_Class_3)arg_1).var_3 = (byte)+ -9.9100855E36F)]).var_38 = (var_43 ? "k" : Tester_Class_2.var_19).substring(350785312);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

552 return (new Tester_Interface_0[(byte)'l'])[((Tester_Class_1)(var_39 = (Tester_Class_3.var_27 = (Tester_Class_3)arg_1))).var_3 = ((Tester_Class_3.var_27 = arg_1).var_3 = (((Tester_Class_3)arg_1).var_3 = (arg_1.var_3 = (arg_1.var_3 = (byte)'['))))];

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

553 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

554

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

555 private final int func_9(Tester_Class_3 arg_0, char arg_1)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

556 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

557 final float var_68 = Tester_Class_3.var_9;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

558 Tester_Class_2.var_18.toLowerCase();

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

559 double var_69;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

560 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

561 Tester_Class_3.var_29 ^= !false || Tester_Class_2.var_4;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

562 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

563 Tester_Class_1 var_70;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

564 (Tester_Class_3.var_27 = (Tester_Class_2)(var_70 = arg_0)).var_6 = (Tester_Class_2)((var_41 = arg_0).var_6 = (arg_0.var_6 = arg_0));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

565 "hv".codePointBefore(--Tester_Class_2.var_1);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

566 var_41 = arg_0;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

567 return ~ (((arg_0 = arg_0).var_24 &= arg_1) == 3.0764282E38F ? (byte)457565863 : ((arg_0 = arg_0).var_3 = (byte)arg_0.var_28));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

568 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

569

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

570 private static void func_10(double arg_0, final Tester_Class_3 arg_1, double arg_2)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

571 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

572 arg_1.var_32 = 'g' != 1.520646515461986E307 ? (arg_1.var_32 = arg_1) : arg_1;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

573 Tester_Class_2.var_19.startsWith(Tester_Class_2.var_19 = Tester_Class_3.var_18);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

574 Tester_Class_1.var_4 ^= true & (arg_1.var_3 = (arg_1.var_3 = (byte)- ((byte)1.4509185661781193E308))) > (arg_1.var_2 = var_40);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

575 var_36 += Tester_Class_3.var_9;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

576 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

577

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

578 Tester_Interface_0 func_12(final Object arg_0, float arg_1)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

579 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

580 switch (((Tester_Class_3)arg_0).var_3 = (byte)arg_1)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

581 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

582 case 4:

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

583 var_41 = (Tester_Class_3)(var_39 = (Tester_Class_3.var_27 = (Tester_Class_3.var_27 = (Tester_Class_3)arg_0)));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

584 double var_72 = (double)3858573493713776640L;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

585 byte var_73 = (var_41 = (Tester_Class_2)arg_0).var_3 = (((Tester_Class_3)arg_0).var_3 = (byte)var_72);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

586 break;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

587

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

588 case 13:

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

589 (Tester_Class_3.var_27 = (((Tester_Class_3)arg_0).var_32 = (Tester_Class_3)(Tester_Class_2)arg_0)).var_3 = (Tester_Class_2.var_1 *= ((Tester_Class_3)arg_0).var_24) == (byte)Tester_Class_3.var_33 ? (byte)188693954866039808L : (byte)Tester_Class_2.var_8;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

590 break;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

591

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

592 default:

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

593 var_40 <<= (byte)157510337;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

594 break;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

595

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

596 case 26:

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

597

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

598 case 122:

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

599

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

600 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

601 Tester_Interface_0 var_74;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

602 long var_75;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

603 var_41 = (var_41 = (var_41 = (Tester_Class_2)arg_0));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

604 arg_1 *= 1601420762;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

605 var_74 = (var_41 = Tester_Class_1.var_4 ? (Tester_Class_3)arg_0 : (Tester_Class_2)arg_0);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

606 (Tester_Class_1.var_4 ? (Tester_Class_3)(var_39 = (Tester_Class_3)arg_0) : (true ? (Tester_Class_3)arg_0 : (Tester_Class_3)arg_0)).var_28 *= 1066935145;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

607 var_40 >>>= (byte)6.643183E36F / - ((byte)1.277596E37F);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

608 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

609 ((Tester_Class_3)(((Tester_Class_3)((Tester_Class_3.var_29 ^= (Tester_Class_3.var_29 &= var_43)) ? (Tester_Class_2)arg_0 : (Tester_Class_2)arg_0)).var_32 = (Tester_Class_3.var_27 = (Tester_Class_2)arg_0))).var_28--;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

610 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

611 var_38 = "qad";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

612 byte var_76 = ((Tester_Class_2)(var_39 = (Tester_Class_3)arg_0)).var_3 = true ? ((var_41 = (var_41 = (Tester_Class_3)arg_0)).var_3 = (byte)1.7128118638075888E308) : (byte)1.6562746603631249E308;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

613 return var_39 = (Tester_Class_3)((var_41 = (Tester_Class_3)arg_0).var_6 = Tester_Class_2.var_18);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

614 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

615

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

616 protected final String func_13()

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

617 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

618 float var_77;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

619 var_38 = (Tester_Class_2.var_19 = var_38);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

620 Tester_Class_2.var_4 ^= !var_43 | (Tester_Class_3.var_29 ^= Tester_Class_1.var_4);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

621 Tester_Class_3.var_1--;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

622 Tester_Class_2.var_1++;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

623 return Tester_Class_2.var_18;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

624 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

625

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

626 public static String execute()

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

627 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

628 try {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

629 Tester t = new Tester();

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

630 try { t.test(); }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

631 catch(Throwable e) { }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

632 try { return t.toString(); }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

633 catch (Throwable e) { return "Error during result conversion to String"; }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

634 } catch (Throwable e) { return "Error during test execution"; }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

635 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

636

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

637 public static void main(String[] args)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

638 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

639 try {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

640 Tester t = new Tester();

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

641 try { t.test(); }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

642 catch(Throwable e) { }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

643 try { System.out.println(t); }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

644 catch(Throwable e) { }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

645 } catch (Throwable e) { }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

646 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

647

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

648 private void test()

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

649 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

650 int var_78 = 0;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

651 var_39 = (new Tester_Class_1[(byte)var_40])[(byte)Tester_Class_3.var_33];

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

652 while (var_43 && (var_78 < 70 && true))

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

653 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

654 var_40 *= ~ ~Tester_Class_3.var_33 % Tester_Class_3.var_9;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

655 var_78++;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

656 var_39 = new Tester_Class_3();

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

657 var_39 = (var_41 = (Tester_Class_3.var_27 = new Tester_Class_2()));

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

658 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

659 final Tester_Class_3 var_79 = (Tester_Class_1.var_4 ? ~Tester_Class_3.var_33 : var_36) == 1433764895112462336L ? new Tester_Class_3() : new Tester_Class_3();

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

660 Tester_Class_2 var_80;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

661 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

662 public String toString()

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

663 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

664 String result = "[\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

665 result += "Tester.var_40 = "; result += Printer.print(var_40);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

666 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

667 result += "Tester.var_42 = "; result += Printer.print(var_42);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

668 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

669 result += "Tester.var_36 = "; result += Printer.print(var_36);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

670 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

671 result += "Tester.var_37 = "; result += Printer.print(var_37);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

672 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

673 result += "Tester.var_39 = "; result += Printer.print(var_39);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

674 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

675 result += "Tester.var_38 = "; result += Printer.print(var_38);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

676 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

677 result += "Tester.var_43 = "; result += Printer.print(var_43);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

678 result += "\n";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

679 result += "Tester.var_41 = "; result += Printer.print(var_41);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

680 result += "";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

681 result += "\n]";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

682 return result;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

683 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

684 static class Printer

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

685 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

686 public static String print(boolean arg) { return String.valueOf(arg); }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

687 public static String print(byte arg) { return String.valueOf(arg); }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

688 public static String print(short arg) { return String.valueOf(arg); }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

689 public static String print(char arg) { return String.valueOf((int)arg); }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

690 public static String print(int arg) { return String.valueOf(arg); }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

691 public static String print(long arg) { return String.valueOf(arg); }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

692 public static String print(float arg) { return String.valueOf(arg); }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

693 public static String print(double arg) { return String.valueOf(arg); }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

694

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

695

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

696 public static String print(Object arg)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

697 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

698 return print_r(new java.util.Stack(), arg);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

699 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

700

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

701 private static String print_r(java.util.Stack visitedObjects, Object arg)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

702 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

703 String result = "";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

704 if (arg == null)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

705 result += "null";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

706 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

707 if (arg.getClass().isArray())

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

708 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

709 for (int i = 0; i < visitedObjects.size(); i++)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

710 if (visitedObjects.elementAt(i) == arg) return "<recursive>";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

711

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

712 visitedObjects.push(arg);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

713

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

714 final String delimiter = ", ";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

715 result += "[";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

716

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

717 if (arg instanceof Object[])

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

718 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

719 Object[] array = (Object[]) arg;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

720 for (int i = 0; i < array.length; i++)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

721 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

722 result += print_r(visitedObjects, array[i]);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

723 if (i < array.length - 1) result += delimiter;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

724 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

725 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

726 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

727 if (arg instanceof boolean[])

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

728 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

729 boolean[] array = (boolean[]) arg;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

730 for (int i = 0; i < array.length; i++)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

731 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

732 result += print(array[i]);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

733 if (i < array.length - 1) result += delimiter;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

734 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

735 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

736 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

737 if (arg instanceof byte[])

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

738 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

739 byte[] array = (byte[]) arg;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

740 for (int i = 0; i < array.length; i++)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

741 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

742 result += print(array[i]);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

743 if (i < array.length - 1) result += delimiter;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

744 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

745 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

746 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

747 if (arg instanceof short[])

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

748 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

749 short[] array = (short[]) arg;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

750 for (int i = 0; i < array.length; i++)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

751 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

752 result += print(array[i]);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

753 if (i < array.length - 1) result += delimiter;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

754 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

755 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

756 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

757 if (arg instanceof char[])

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

758 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

759 char[] array = (char[]) arg;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

760 for (int i = 0; i < array.length; i++)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

761 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

762 result += print(array[i]);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

763 if (i < array.length - 1) result += delimiter;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

764 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

765 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

766 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

767 if (arg instanceof int[])

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

768 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

769 int[] array = (int[]) arg;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

770 for (int i = 0; i < array.length; i++)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

771 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

772 result += print(array[i]);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

773 if (i < array.length - 1) result += delimiter;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

774 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

775 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

776 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

777 if (arg instanceof long[])

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

778 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

779 long[] array = (long[]) arg;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

780 for (int i = 0; i < array.length; i++)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

781 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

782 result += print(array[i]);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

783 if (i < array.length - 1) result += delimiter;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

784 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

785 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

786 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

787 if (arg instanceof float[])

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

788 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

789 float[] array = (float[]) arg;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

790 for (int i = 0; i < array.length; i++)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

791 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

792 result += print(array[i]);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

793 if (i < array.length - 1) result += delimiter;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

794 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

795 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

796 else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

797 if (arg instanceof double[])

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

798 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

799 double[] array = (double[]) arg;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

800 for (int i = 0; i < array.length; i++)

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

801 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

802 result += print(array[i]);

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

803 if (i < array.length - 1) result += delimiter;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

804 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

805 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

806

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

807 result += "]";

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

808 visitedObjects.pop();

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

809

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

810 } else

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

811 {

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

812 result += arg.toString();

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

813 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

814

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

815 return result;

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

816 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

817 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

818 }

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

819

273eaa04d9a1 6714694: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs

kvn

parents:

diff changeset

820

Mercurial > hg > truffle

annotate test/compiler/6714694/Tester.java @ 215:273eaa04d9a1