Merge "Reproduce b/77240639"
diff --git a/src/test/java/com/android/tools/r8/ir/regalloc/B77240639.java b/src/test/java/com/android/tools/r8/ir/regalloc/B77240639.java
new file mode 100644
index 0000000..440f4f3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/regalloc/B77240639.java
@@ -0,0 +1,820 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.regalloc;
+
+import static com.android.tools.r8.utils.DexInspectorMatchers.isPresent;
+import static org.junit.Assert.assertThat;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.DexInspector;
+import com.android.tools.r8.utils.DexInspector.ClassSubject;
+import java.util.List;
+import java.util.Map;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class B77240639 extends TestBase {
+ @Ignore("b/77240639")
+ @Test
+ public void test() throws Exception {
+ AndroidApp app = compileWithD8(readClasses(TestClass.class));
+ DexInspector inspector = new DexInspector(app);
+ ClassSubject clazz = inspector.clazz(TestClass.class);
+ assertThat(clazz, isPresent());
+ }
+}
+
+class TestClass {
+ private boolean b;
+ private boolean b_flag = false;
+ private Boolean ob;
+ private boolean ob_flag = false;
+ private List<Boolean> vb;
+ private boolean vb_flag = false;
+ private List<Boolean> vob;
+ private boolean vob_flag = false;
+ private Map<String, Boolean> db;
+ private boolean db_flag = false;
+ private Map<String, Boolean> dob;
+ private boolean dob_flag = false;
+ private int i;
+ private boolean i_flag = false;
+ private Integer oi;
+ private boolean oi_flag = false;
+ private List<Boolean> vi;
+ private boolean vi_flag = false;
+ private List<Boolean> voi;
+ private boolean voi_flag = false;
+ private Map<String, Boolean> di;
+ private boolean di_flag = false;
+ private Map<String, Boolean> doi;
+ private boolean doi_flag = false;
+ private int ui;
+ private boolean ui_flag = false;
+ private Integer oui;
+ private boolean oui_flag = false;
+ private List<Boolean> vui;
+ private boolean vui_flag = false;
+ private List<Boolean> voui;
+ private boolean voui_flag = false;
+ private Map<String, Boolean> dui;
+ private boolean dui_flag = false;
+ private Map<String, Boolean> doui;
+ private boolean doui_flag = false;
+ private long i64;
+ private boolean i64_flag = false;
+ private Long oi64;
+ private boolean oi64_flag = false;
+ private List<Boolean> vi64;
+ private boolean vi64_flag = false;
+ private List<Boolean> voi64;
+ private boolean voi64_flag = false;
+ private Map<String, Boolean> di64;
+ private boolean di64_flag = false;
+ private Map<String, Boolean> doi64;
+ private boolean doi64_flag = false;
+ private float fl;
+ private boolean fl_flag = false;
+ private Float ofl;
+ private boolean ofl_flag = false;
+ private List<Boolean> vfl;
+ private boolean vfl_flag = false;
+ private List<Boolean> vofl;
+ private boolean vofl_flag = false;
+ private Map<String, Boolean> dfl;
+ private boolean dfl_flag = false;
+ private Map<String, Boolean> dofl;
+ private boolean dofl_flag = false;
+ private double d;
+ private boolean d_flag = false;
+ private Double od;
+ private boolean od_flag = false;
+ private List<Boolean> vd;
+ private boolean vd_flag = false;
+ private List<Boolean> vod;
+ private boolean vod_flag = false;
+ private Map<String, Boolean> dd;
+ private boolean dd_flag = false;
+ private Map<String, Boolean> dod;
+ private boolean dod_flag = false;
+ private String s;
+ private boolean s_flag = false;
+ private String os;
+ private boolean os_flag = false;
+ private List<Boolean> vs;
+ private boolean vs_flag = false;
+ private List<Boolean> vos;
+ private boolean vos_flag = false;
+ private Map<String, Boolean> ds;
+ private boolean ds_flag = false;
+ private Map<String, Boolean> dos;
+ private boolean dos_flag = false;
+ private long ti;
+ private boolean ti_flag = false;
+ private Long oti;
+ private boolean oti_flag = false;
+ private List<Boolean> vti;
+ private boolean vti_flag = false;
+ private List<Boolean> voti;
+ private boolean voti_flag = false;
+ private Map<String, Boolean> dti;
+ private boolean dti_flag = false;
+ private Map<String, Boolean> doti;
+ private boolean doti_flag = false;
+ private long at;
+ private boolean at_flag = false;
+ private Long oat;
+ private boolean oat_flag = false;
+ private List<Boolean> vat;
+ private boolean vat_flag = false;
+ private List<Boolean> voat;
+ private boolean voat_flag = false;
+ private Map<String, Boolean> dat;
+ private boolean dat_flag = false;
+ private Map<String, Boolean> doat;
+ private boolean doat_flag = false;
+ private long rt;
+ private boolean rt_flag = false;
+ private Long ort;
+ private boolean ort_flag = false;
+ private List<Boolean> vrt;
+ private boolean vrt_flag = false;
+ private List<Boolean> vort;
+ private boolean vort_flag = false;
+ private Map<String, Boolean> drt;
+ private boolean drt_flag = false;
+ private Map<String, Boolean> dort;
+ private boolean dort_flag = false;
+ private byte[] by;
+ private boolean by_flag = false;
+ private byte[] oby;
+ private boolean oby_flag = false;
+ private int c;
+ private boolean c_flag = false;
+ private Integer oc;
+ private boolean oc_flag = false;
+ private List<Integer> vc;
+ private boolean vc_flag = false;
+ private List<Integer> voc;
+ private boolean voc_flag = false;
+ private Map<String, Integer> dc;
+ private boolean dc_flag = false;
+ private Map<String, Integer> doc;
+ private boolean doc_flag = false;
+ private Object p;
+ private boolean p_flag = false;
+ private Object op;
+ private boolean op_flag = false;
+ private List<Object> vp;
+ private boolean vp_flag = false;
+ private List<Object> vop;
+ private boolean vop_flag = false;
+ private Map<String, Object> dp;
+ private boolean dp_flag = false;
+ private Map<String, Object> dop;
+ private boolean dop_flag = false;
+ private Object e;
+ private boolean e_flag = false;
+ private Object oe;
+ private boolean oe_flag = false;
+ private List<Object> ve;
+ private boolean ve_flag = false;
+ private List<Object> voe;
+ private boolean voe_flag = false;
+ private Map<String, Object> de;
+ private boolean de_flag = false;
+ private Map<String, Object> doe;
+ private boolean doe_flag = false;
+ private int be;
+ private boolean be_flag = false;
+ private Integer obe;
+ private boolean obe_flag = false;
+ private List<Object> vbe;
+ private boolean vbe_flag = false;
+ private List<Object> vobe;
+ private boolean vobe_flag = false;
+ private Map<String, Object> dbe;
+ private boolean dbe_flag = false;
+ private Map<String, Object> dobe;
+ private boolean dobe_flag = false;
+ private Object ts;
+ private boolean ts_flag = false;
+ private Object ots;
+ private boolean ots_flag = false;
+ private List<Object> vts;
+ private boolean vts_flag = false;
+ private List<Object> vots;
+ private boolean vots_flag = false;
+ private Map<String, Object> dts;
+ private boolean dts_flag = false;
+ private Map<String, Object> dots;
+ private boolean dots_flag = false;
+ private Object lts;
+ private boolean lts_flag = false;
+ private Object olts;
+ private boolean olts_flag = false;
+ private List<Object> vlts;
+ private boolean vlts_flag = false;
+ private List<Object> volts;
+ private boolean volts_flag = false;
+ private Map<String, Object> dlts;
+ private boolean dlts_flag = false;
+ private Map<String, Object> dolts;
+ private boolean dolts_flag = false;
+ private Object opts;
+ private boolean opts_flag = false;
+ private Object oopts;
+ private boolean oopts_flag = false;
+ private List<Object> vopts;
+ private boolean vopts_flag = false;
+ private List<Object> voopts;
+ private boolean voopts_flag = false;
+ private Map<String, Object> dopts;
+ private boolean dopts_flag = false;
+ private Map<String, Object> doopts;
+ private boolean doopts_flag = false;
+ private Object nativeObject;
+
+ public TestClass() {}
+
+ public TestClass(
+ boolean b,
+ Boolean ob,
+ List<Boolean> vb,
+ List<Boolean> vob,
+ Map<String, Boolean> db,
+ Map<String, Boolean> dob,
+ int i,
+ Integer oi,
+ List<Boolean> vi,
+ List<Boolean> voi,
+ Map<String, Boolean> di,
+ Map<String, Boolean> doi,
+ int ui,
+ Integer oui,
+ List<Boolean> vui,
+ List<Boolean> voui,
+ Map<String, Boolean> dui,
+ Map<String, Boolean> doui,
+ long i64,
+ Long oi64,
+ List<Boolean> vi64,
+ List<Boolean> voi64,
+ Map<String, Boolean> di64,
+ Map<String, Boolean> doi64,
+ float fl,
+ Float ofl,
+ List<Boolean> vfl,
+ List<Boolean> vofl,
+ Map<String, Boolean> dfl,
+ Map<String, Boolean> dofl,
+ double d,
+ Double od,
+ List<Boolean> vd,
+ List<Boolean> vod,
+ Map<String, Boolean> dd,
+ Map<String, Boolean> dod,
+ String s,
+ String os,
+ List<Boolean> vs,
+ List<Boolean> vos,
+ Map<String, Boolean> ds,
+ Map<String, Boolean> dos,
+ long ti,
+ Long oti,
+ List<Boolean> vti,
+ List<Boolean> voti,
+ Map<String, Boolean> dti,
+ Map<String, Boolean> doti,
+ long at,
+ Long oat,
+ List<Boolean> vat,
+ List<Boolean> voat,
+ Map<String, Boolean> dat,
+ Map<String, Boolean> doat,
+ long rt,
+ Long ort,
+ List<Boolean> vrt,
+ List<Boolean> vort,
+ Map<String, Boolean> drt,
+ Map<String, Boolean> dort,
+ byte[] by,
+ byte[] oby,
+ int c,
+ Integer oc,
+ List<Integer> vc,
+ List<Integer> voc,
+ Map<String, Integer> dc,
+ Map<String, Integer> doc,
+ Object p,
+ Object op,
+ List<Object> vp,
+ List<Object> vop,
+ Map<String, Object> dp,
+ Map<String, Object> dop,
+ Object e,
+ Object oe,
+ List<Object> ve,
+ List<Object> voe,
+ Map<String, Object> de,
+ Map<String, Object> doe,
+ int be,
+ Integer obe,
+ List<Object> vbe,
+ List<Object> vobe,
+ Map<String, Object> dbe,
+ Map<String, Object> dobe,
+ Object ts,
+ Object ots,
+ List<Object> vts,
+ List<Object> vots,
+ Map<String, Object> dts,
+ Map<String, Object> dots,
+ Object lts,
+ Object olts,
+ List<Object> vlts,
+ List<Object> volts,
+ Map<String, Object> dlts,
+ Map<String, Object> dolts,
+ Object opts,
+ Object oopts,
+ List<Object> vopts,
+ List<Object> voopts,
+ Map<String, Object> dopts,
+ Map<String, Object> doopts) {
+ if (vb == null) {
+ throw new IllegalArgumentException("vb");
+ } else if (vob == null) {
+ throw new IllegalArgumentException("vob");
+ } else if (db == null) {
+ throw new IllegalArgumentException("db");
+ } else if (dob == null) {
+ throw new IllegalArgumentException("dob");
+ } else if (vi == null) {
+ throw new IllegalArgumentException("vi");
+ } else if (voi == null) {
+ throw new IllegalArgumentException("voi");
+ } else if (di == null) {
+ throw new IllegalArgumentException("di");
+ } else if (doi == null) {
+ throw new IllegalArgumentException("doi");
+ } else if (vui == null) {
+ throw new IllegalArgumentException("vui");
+ } else if (voui == null) {
+ throw new IllegalArgumentException("voui");
+ } else if (dui == null) {
+ throw new IllegalArgumentException("dui");
+ } else if (doui == null) {
+ throw new IllegalArgumentException("doui");
+ } else if (vi64 == null) {
+ throw new IllegalArgumentException("vi64");
+ } else if (voi64 == null) {
+ throw new IllegalArgumentException("voi64");
+ } else if (di64 == null) {
+ throw new IllegalArgumentException("di64");
+ } else if (doi64 == null) {
+ throw new IllegalArgumentException("doi64");
+ } else if (vfl == null) {
+ throw new IllegalArgumentException("vfl");
+ } else if (vofl == null) {
+ throw new IllegalArgumentException("vofl");
+ } else if (dfl == null) {
+ throw new IllegalArgumentException("dfl");
+ } else if (dofl == null) {
+ throw new IllegalArgumentException("dofl");
+ } else if (vd == null) {
+ throw new IllegalArgumentException("vd");
+ } else if (vod == null) {
+ throw new IllegalArgumentException("vod");
+ } else if (dd == null) {
+ throw new IllegalArgumentException("dd");
+ } else if (dod == null) {
+ throw new IllegalArgumentException("dod");
+ } else if (s == null) {
+ throw new IllegalArgumentException("s");
+ } else if (vs == null) {
+ throw new IllegalArgumentException("vs");
+ } else if (vos == null) {
+ throw new IllegalArgumentException("vos");
+ } else if (ds == null) {
+ throw new IllegalArgumentException("ds");
+ } else if (dos == null) {
+ throw new IllegalArgumentException("dos");
+ } else if (vti == null) {
+ throw new IllegalArgumentException("vti");
+ } else if (voti == null) {
+ throw new IllegalArgumentException("voti");
+ } else if (dti == null) {
+ throw new IllegalArgumentException("dti");
+ } else if (doti == null) {
+ throw new IllegalArgumentException("doti");
+ } else if (vat == null) {
+ throw new IllegalArgumentException("vat");
+ } else if (voat == null) {
+ throw new IllegalArgumentException("voat");
+ } else if (dat == null) {
+ throw new IllegalArgumentException("dat");
+ } else if (doat == null) {
+ throw new IllegalArgumentException("doat");
+ } else if (vrt == null) {
+ throw new IllegalArgumentException("vrt");
+ } else if (vort == null) {
+ throw new IllegalArgumentException("vort");
+ } else if (drt == null) {
+ throw new IllegalArgumentException("drt");
+ } else if (dort == null) {
+ throw new IllegalArgumentException("dort");
+ } else if (by == null) {
+ throw new IllegalArgumentException("by");
+ } else if (vc == null) {
+ throw new IllegalArgumentException("vc");
+ } else if (voc == null) {
+ throw new IllegalArgumentException("voc");
+ } else if (dc == null) {
+ throw new IllegalArgumentException("dc");
+ } else if (doc == null) {
+ throw new IllegalArgumentException("doc");
+ } else if (p == null) {
+ throw new IllegalArgumentException("p");
+ } else if (vp == null) {
+ throw new IllegalArgumentException("vp");
+ } else if (vop == null) {
+ throw new IllegalArgumentException("vop");
+ } else if (dp == null) {
+ throw new IllegalArgumentException("dp");
+ } else if (dop == null) {
+ throw new IllegalArgumentException("dop");
+ } else if (e == null) {
+ throw new IllegalArgumentException("e");
+ } else if (ve == null) {
+ throw new IllegalArgumentException("ve");
+ } else if (voe == null) {
+ throw new IllegalArgumentException("voe");
+ } else if (de == null) {
+ throw new IllegalArgumentException("de");
+ } else if (doe == null) {
+ throw new IllegalArgumentException("doe");
+ } else if (vbe == null) {
+ throw new IllegalArgumentException("vbe");
+ } else if (vobe == null) {
+ throw new IllegalArgumentException("vobe");
+ } else if (dbe == null) {
+ throw new IllegalArgumentException("dbe");
+ } else if (dobe == null) {
+ throw new IllegalArgumentException("dobe");
+ } else if (ts == null) {
+ throw new IllegalArgumentException("ts");
+ } else if (vts == null) {
+ throw new IllegalArgumentException("vts");
+ } else if (vots == null) {
+ throw new IllegalArgumentException("vots");
+ } else if (dts == null) {
+ throw new IllegalArgumentException("dts");
+ } else if (dots == null) {
+ throw new IllegalArgumentException("dots");
+ } else if (lts == null) {
+ throw new IllegalArgumentException("lts");
+ } else if (vlts == null) {
+ throw new IllegalArgumentException("vlts");
+ } else if (volts == null) {
+ throw new IllegalArgumentException("volts");
+ } else if (dlts == null) {
+ throw new IllegalArgumentException("dlts");
+ } else if (dolts == null) {
+ throw new IllegalArgumentException("dolts");
+ } else if (opts == null) {
+ throw new IllegalArgumentException("opts");
+ } else if (vopts == null) {
+ throw new IllegalArgumentException("vopts");
+ } else if (voopts == null) {
+ throw new IllegalArgumentException("voopts");
+ } else if (dopts == null) {
+ throw new IllegalArgumentException("dopts");
+ } else if (doopts == null) {
+ throw new IllegalArgumentException("doopts");
+ } else {
+ this.nativeObject =
+ this.init(
+ b, ob, vb, vob, db, dob, i, oi, vi, voi, di, doi, ui, oui, vui, voui, dui, doui, i64,
+ oi64, vi64, voi64, di64, doi64, fl, ofl, vfl, vofl, dfl, dofl, d, od, vd, vod, dd,
+ dod, s, os, vs, vos, ds, dos, ti, oti, vti, voti, dti, doti, at, oat, vat, voat, dat,
+ doat, rt, ort, vrt, vort, drt, dort, by, oby, c, oc, vc, voc, dc, doc, p, op, vp, vop,
+ dp, dop, e, oe, ve, voe, de, doe, be, obe, vbe, vobe, dbe, dobe, ts, ots, vts, vots,
+ dts, dots, lts, olts, vlts, volts, dlts, dolts, opts, oopts, vopts, voopts, dopts,
+ doopts);
+ this.b = b;
+ this.b_flag = true;
+ this.ob = ob;
+ this.ob_flag = true;
+ this.vb = vb;
+ this.vb_flag = true;
+ this.vob = vob;
+ this.vob_flag = true;
+ this.db = db;
+ this.db_flag = true;
+ this.dob = dob;
+ this.dob_flag = true;
+ this.i = i;
+ this.i_flag = true;
+ this.oi = oi;
+ this.oi_flag = true;
+ this.vi = vi;
+ this.vi_flag = true;
+ this.voi = voi;
+ this.voi_flag = true;
+ this.di = di;
+ this.di_flag = true;
+ this.doi = doi;
+ this.doi_flag = true;
+ this.ui = ui;
+ this.ui_flag = true;
+ this.oui = oui;
+ this.oui_flag = true;
+ this.vui = vui;
+ this.vui_flag = true;
+ this.voui = voui;
+ this.voui_flag = true;
+ this.dui = dui;
+ this.dui_flag = true;
+ this.doui = doui;
+ this.doui_flag = true;
+ this.i64 = i64;
+ this.i64_flag = true;
+ this.oi64 = oi64;
+ this.oi64_flag = true;
+ this.vi64 = vi64;
+ this.vi64_flag = true;
+ this.voi64 = voi64;
+ this.voi64_flag = true;
+ this.di64 = di64;
+ this.di64_flag = true;
+ this.doi64 = doi64;
+ this.doi64_flag = true;
+ this.fl = fl;
+ this.fl_flag = true;
+ this.ofl = ofl;
+ this.ofl_flag = true;
+ this.vfl = vfl;
+ this.vfl_flag = true;
+ this.vofl = vofl;
+ this.vofl_flag = true;
+ this.dfl = dfl;
+ this.dfl_flag = true;
+ this.dofl = dofl;
+ this.dofl_flag = true;
+ this.d = d;
+ this.d_flag = true;
+ this.od = od;
+ this.od_flag = true;
+ this.vd = vd;
+ this.vd_flag = true;
+ this.vod = vod;
+ this.vod_flag = true;
+ this.dd = dd;
+ this.dd_flag = true;
+ this.dod = dod;
+ this.dod_flag = true;
+ this.s = s;
+ this.s_flag = true;
+ this.os = os;
+ this.os_flag = true;
+ this.vs = vs;
+ this.vs_flag = true;
+ this.vos = vos;
+ this.vos_flag = true;
+ this.ds = ds;
+ this.ds_flag = true;
+ this.dos = dos;
+ this.dos_flag = true;
+ this.ti = ti;
+ this.ti_flag = true;
+ this.oti = oti;
+ this.oti_flag = true;
+ this.vti = vti;
+ this.vti_flag = true;
+ this.voti = voti;
+ this.voti_flag = true;
+ this.dti = dti;
+ this.dti_flag = true;
+ this.doti = doti;
+ this.doti_flag = true;
+ this.at = at;
+ this.at_flag = true;
+ this.oat = oat;
+ this.oat_flag = true;
+ this.vat = vat;
+ this.vat_flag = true;
+ this.voat = voat;
+ this.voat_flag = true;
+ this.dat = dat;
+ this.dat_flag = true;
+ this.doat = doat;
+ this.doat_flag = true;
+ this.rt = rt;
+ this.rt_flag = true;
+ this.ort = ort;
+ this.ort_flag = true;
+ this.vrt = vrt;
+ this.vrt_flag = true;
+ this.vort = vort;
+ this.vort_flag = true;
+ this.drt = drt;
+ this.drt_flag = true;
+ this.dort = dort;
+ this.dort_flag = true;
+ this.by = by;
+ this.by_flag = true;
+ this.oby = oby;
+ this.oby_flag = true;
+ this.c = c;
+ this.c_flag = true;
+ this.oc = oc;
+ this.oc_flag = true;
+ this.vc = vc;
+ this.vc_flag = true;
+ this.voc = voc;
+ this.voc_flag = true;
+ this.dc = dc;
+ this.dc_flag = true;
+ this.doc = doc;
+ this.doc_flag = true;
+ this.p = p;
+ this.p_flag = true;
+ this.op = op;
+ this.op_flag = true;
+ this.vp = vp;
+ this.vp_flag = true;
+ this.vop = vop;
+ this.vop_flag = true;
+ this.dp = dp;
+ this.dp_flag = true;
+ this.dop = dop;
+ this.dop_flag = true;
+ this.e = e;
+ this.e_flag = true;
+ this.oe = oe;
+ this.oe_flag = true;
+ this.ve = ve;
+ this.ve_flag = true;
+ this.voe = voe;
+ this.voe_flag = true;
+ this.de = de;
+ this.de_flag = true;
+ this.doe = doe;
+ this.doe_flag = true;
+ this.be = be;
+ this.be_flag = true;
+ this.obe = obe;
+ this.obe_flag = true;
+ this.vbe = vbe;
+ this.vbe_flag = true;
+ this.vobe = vobe;
+ this.vobe_flag = true;
+ this.dbe = dbe;
+ this.dbe_flag = true;
+ this.dobe = dobe;
+ this.dobe_flag = true;
+ this.ts = ts;
+ this.ts_flag = true;
+ this.ots = ots;
+ this.ots_flag = true;
+ this.vts = vts;
+ this.vts_flag = true;
+ this.vots = vots;
+ this.vots_flag = true;
+ this.dts = dts;
+ this.dts_flag = true;
+ this.dots = dots;
+ this.dots_flag = true;
+ this.lts = lts;
+ this.lts_flag = true;
+ this.olts = olts;
+ this.olts_flag = true;
+ this.vlts = vlts;
+ this.vlts_flag = true;
+ this.volts = volts;
+ this.volts_flag = true;
+ this.dlts = dlts;
+ this.dlts_flag = true;
+ this.dolts = dolts;
+ this.dolts_flag = true;
+ this.opts = opts;
+ this.opts_flag = true;
+ this.oopts = oopts;
+ this.oopts_flag = true;
+ this.vopts = vopts;
+ this.vopts_flag = true;
+ this.voopts = voopts;
+ this.voopts_flag = true;
+ this.dopts = dopts;
+ this.dopts_flag = true;
+ this.doopts = doopts;
+ this.doopts_flag = true;
+ }
+ }
+
+ private native Object init(
+ boolean v1,
+ Boolean v2,
+ List<Boolean> v3,
+ List<Boolean> v4,
+ Map<String, Boolean> v5,
+ Map<String, Boolean> v6,
+ int v7, Integer var8,
+ List<Boolean> v9,
+ List<Boolean> v10,
+ Map<String, Boolean> v11,
+ Map<String, Boolean> v12,
+ int v13,
+ Integer v14,
+ List<Boolean> v15,
+ List<Boolean> v16,
+ Map<String, Boolean> v17,
+ Map<String, Boolean> v18,
+ long v19, Long var21,
+ List<Boolean> v22,
+ List<Boolean> v23,
+ Map<String, Boolean> v24,
+ Map<String, Boolean> v25,
+ float v26,
+ Float v27,
+ List<Boolean> v28,
+ List<Boolean> v29,
+ Map<String, Boolean> v30,
+ Map<String, Boolean> v31,
+ double v32,
+ Double v34,
+ List<Boolean> v35,
+ List<Boolean> v36,
+ Map<String, Boolean> v37,
+ Map<String, Boolean> v38,
+ String v39,
+ String v40,
+ List<Boolean> v41,
+ List<Boolean> v42,
+ Map<String, Boolean> v43,
+ Map<String, Boolean> v44,
+ long v45, Long var47,
+ List<Boolean> v48,
+ List<Boolean> v49,
+ Map<String, Boolean> v50,
+ Map<String, Boolean> v51,
+ long v52,
+ Long v54,
+ List<Boolean> v55,
+ List<Boolean> v56,
+ Map<String, Boolean> v57,
+ Map<String, Boolean> v58,
+ long v59,
+ Long v61,
+ List<Boolean> v62,
+ List<Boolean> v63,
+ Map<String, Boolean> v64,
+ Map<String, Boolean> v65,
+ byte[] v66,
+ byte[] v67,
+ int v68,
+ Integer v69,
+ List<Integer> v70,
+ List<Integer> v71,
+ Map<String, Integer> v72,
+ Map<String, Integer> v73,
+ Object v74,
+ Object v75,
+ List<Object> v76,
+ List<Object> v77,
+ Map<String, Object> v78,
+ Map<String, Object> v79,
+ Object v80,
+ Object v81,
+ List<Object> v82,
+ List<Object> v83,
+ Map<String, Object> v84,
+ Map<String, Object> v85,
+ int v86,
+ Integer v87,
+ List<Object> v88,
+ List<Object> v89,
+ Map<String, Object> v90,
+ Map<String, Object> v91,
+ Object v92,
+ Object v93,
+ List<Object> v94,
+ List<Object> v95,
+ Map<String, Object> v96,
+ Map<String, Object> v97,
+ Object v98,
+ Object v99,
+ List<Object> v100,
+ List<Object> v101,
+ Map<String, Object> v102,
+ Map<String, Object> v103,
+ Object v104,
+ Object v105,
+ List<Object> v106,
+ List<Object> v107,
+ Map<String, Object> v108,
+ Map<String, Object> v109);
+}
