X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Forg%2Fibex%2Fclassgen%2FMethodGen.java;h=383ed57e865b1b1b53a8580b6fe1ebd74b4ecca5;hb=85004bd030f69603a32140de6f61891c349b6b4f;hp=d3753161b818af88c635d7220da518210768fd87;hpb=1a607deb9b281751feb3c57b163d17f7d1c0c801;p=org.ibex.classgen.git diff --git a/src/org/ibex/classgen/MethodGen.java b/src/org/ibex/classgen/MethodGen.java index d375316..383ed57 100644 --- a/src/org/ibex/classgen/MethodGen.java +++ b/src/org/ibex/classgen/MethodGen.java @@ -3,16 +3,23 @@ package org.ibex.classgen; import java.io.*; import java.util.*; +// FEATURE: Support WIDE bytecodes + +/** A class representing a method in a generated classfile + @see ClassGen#addMethod */ public class MethodGen implements CGConst { - private final static boolean EMIT_NOPS = true; + private final static boolean EMIT_NOPS = false; + + private static final int NO_CODE = -1; + private static final int FINISHED = -2; private final CPGen cp; private final String name; private final Type ret; private final Type[] args; private final int flags; - private final AttrGen attrs; - private final AttrGen codeAttrs; + private final ClassGen.AttrGen attrs; + private final ClassGen.AttrGen codeAttrs; private final Hashtable exnTable = new Hashtable(); private final Hashtable thrownExceptions = new Hashtable(); @@ -33,8 +40,8 @@ public class MethodGen implements CGConst { this.args = args; this.flags = flags; - attrs = new AttrGen(cp); - codeAttrs = new AttrGen(cp); + attrs = new ClassGen.AttrGen(cp); + codeAttrs = new ClassGen.AttrGen(cp); cp.addUtf8(name); cp.addUtf8(getDescriptor()); @@ -44,6 +51,7 @@ public class MethodGen implements CGConst { maxLocals = Math.max(args.length + (flags&ACC_STATIC)==0 ? 1 : 0,4); } + /** Returns the descriptor string for this method */ public String getDescriptor() { return MethodRef.getDescriptor(ret,args); } private class ExnTableEnt { @@ -65,16 +73,28 @@ public class MethodGen implements CGConst { } } - public final void addExceptionHandler(int startPC, int endPC, int handlerPC, Type.Object type) { - exnTable.put(type, new ExnTableEnt(startPC,endPC,handlerPC,cp.add(type))); + /** Adds an exception handler for the range [start,end) pointing to handler + @param start The instruction to start at (inclusive) + @param end The instruction to end at (exclusive) + @param handler The instruction of the excepton handler + @param type The type of exception that is to be handled (MUST inherit from Throwable) + */ + public final void addExceptionHandler(int start, int end, int handler, Type.Object type) { + exnTable.put(type, new ExnTableEnt(start,end,handler,cp.add(type))); } + /** Adds a exception type that can be thrown from this method + NOTE: This isn't enforced by the JVM. This is for reference only. A method can throw exceptions not declared to be thrown + @param type The type of exception that can be thrown + */ public final void addThrow(Type.Object type) { thrownExceptions.put(type,cp.add(type)); } private final void grow() { if(size == capacity) grow(size+1); } private final void grow(int newCap) { + if(capacity == NO_CODE) throw new IllegalStateException("method can't have code"); + if(capacity == FINISHED) throw new IllegalStateException("method has been finished"); if(newCap <= capacity) return; newCap = Math.max(newCap,capacity == 0 ? 256 : capacity*2); @@ -88,98 +108,159 @@ public class MethodGen implements CGConst { capacity = newCap; } + + /** Returns the size (in instructions) of this method + @return The size of the method (in instructions) + */ public final int size() { return size; } - // FEATURE: Deprecate this - public final int addPushConst(int n) { return add(LDC,n); } - - public final int add(byte op, Object arg) { grow(); set(size,op,arg); return size++; } - public final int add(byte op, boolean arg) { grow(); set(size,op,arg); return size++; } - public final int add(byte op, int arg) { grow(); set(size,op,arg); return size++; } - public final int add(byte op) { grow(); set(size,op); return size++; } + // These two are optimized for speed, they don't call set() below + /** Add a bytecode (with no argument) to the method */ + public final int add(byte op) { + int s = size; + if(s == capacity) grow(); + this.op[s] = op; + size++; + return s; + } + /** Set the bytecode at position pos to op */ + public final void set(int pos, byte op) { this.op[pos] = op; } + /** Adds a bytecode, op, with argument arg to the method + @return The position of the new bytecode + */ + public final int add(byte op, Object arg) { if(capacity == size) grow(); set(size,op,arg); return size++; } + /** Adds a bytecode with a boolean argument - equivalent to add(op,arg?1:0); + @return The position of the new bytecode + @see #add(byte,int) + */ + public final int add(byte op, boolean arg) { if(capacity == size) grow(); set(size,op,arg); return size++; } + /** Adds a bytecode with an integer argument. This is equivalent to add(op,new Integer(arg)), but optimized to prevent the allocation when possible + @return The position of the new bytecode + @see #add(byte,Object) + */ + public final int add(byte op, int arg) { if(capacity == size) grow(); set(size,op,arg); return size++; } + + /** Gets the bytecode at position pos + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + */ public final byte get(int pos) { return op[pos]; } + + /** Gets the bytecode at position pos. NOTE: This isn't necessarily the same object that was set with add or set. + Arguments for instructions which access the constant pool (LDC, INVOKEVIRTUAL, etc) are converted to a more efficient + interal form when they are added. The value returned from this method for these instruction can be reused, but there + is no way to retrieve the original object + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + */ public final Object getArg(int pos) { return arg[pos]; } + /** Sets the argument for pos to arg. This is equivalent to set(pos,op,new Integer(arg)), but optimized to prevent the allocation when possible. + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + @see #setArg(int,Object) */ public final void setArg(int pos, int arg) { set(pos,op[pos],N(arg)); } + /** Sets the argument for pos to arg. + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + */ public final void setArg(int pos, Object arg) { set(pos,op[pos],arg); } - public final void set(int pos, byte op) { set(pos,op,null); } + /** Sets the bytecode and argument at pos to op and arg respectivly. + This is equivalent to set(pos,op,arg?1:0) + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + */ + public final void set(int pos, byte op, boolean arg) { set(pos,op,arg?1:0); } - public final void set(int pos, byte op, boolean b) { set(pos,op,b?1:0); } + // This MUST handle x{LOAD,STORE} and LDC with an int arg WITHOUT falling back to set(int,byte,Object) + /** Sets the bytecode and argument at pos to op and n respectivly. + This is equivalent to set(pos,op, new Integer(n)), but optimized to prevent the allocation when possible. + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + */ public final void set(int pos, byte op, int n) { - if(op == LDC) { - switch(n) { - case -1: set(pos,ICONST_M1); return; - case 0: set(pos,ICONST_0); return; - case 1: set(pos,ICONST_1); return; - case 2: set(pos,ICONST_2); return; - case 3: set(pos,ICONST_3); return; - case 4: set(pos,ICONST_4); return; - case 5: set(pos,ICONST_5); return; - } - if(n >= -128 && n <= 127) set(pos,BIPUSH,N(n)); - else if(n >= -32767 && n <= 32767) set(pos,SIPUSH,N(n)); - else set(pos,LDC,cp.add(N(n))); - } else { - set(pos,op,N(n)); - } - } - - public void set(int pos, byte op, Object arg) { - int iarg = arg instanceof Integer ? ((Integer)arg).intValue() : -1; - - switch(op) { + Object arg = null; + OUTER: switch(op) { + case LDC: + switch(n) { + case -1: op = ICONST_M1; break OUTER; + case 0: op = ICONST_0; break OUTER; + case 1: op = ICONST_1; break OUTER; + case 2: op = ICONST_2; break OUTER; + case 3: op = ICONST_3; break OUTER; + case 4: op = ICONST_4; break OUTER; + case 5: op = ICONST_5; break OUTER; + } + if(n >= -128 && n <= 127) { op = BIPUSH; arg = N(n); } + else if(n >= -32768 && n <= 32767) { op = SIPUSH; arg = N(n); } + else { arg = cp.add(N(n)); } + break; case ILOAD: case ISTORE: case LLOAD: case LSTORE: case FLOAD: case FSTORE: case DLOAD: case DSTORE: case ALOAD: case ASTORE: - { - if(iarg >= 0 && iarg <= 3) { + if(n >= 0 && n <= 3) { byte base = 0; switch(op) { - case ILOAD: base = ILOAD_0; break; + case ILOAD: base = ILOAD_0; break; case ISTORE: base = ISTORE_0; break; - case LLOAD: base = LLOAD_0; break; + case LLOAD: base = LLOAD_0; break; case LSTORE: base = LSTORE_0; break; - case FLOAD: base = FLOAD_0; break; + case FLOAD: base = FLOAD_0; break; case FSTORE: base = FSTORE_0; break; - case DLOAD: base = DLOAD_0; break; + case DLOAD: base = DLOAD_0; break; case DSTORE: base = DSTORE_0; break; - case ALOAD: base = ALOAD_0; break; + case ALOAD: base = ALOAD_0; break; case ASTORE: base = ASTORE_0; break; } - op = (byte)((base&0xff) + iarg); + op = (byte)((base&0xff) + n); } else { - if(iarg >= maxLocals) maxLocals = iarg + 1; + if(n >= maxLocals) maxLocals = n + 1; + arg = N(n); } break; - } + default: + set(pos,op,N(n)); + return; + } + this.op[pos] = op; + this.arg[pos] = arg; + } + + /** Sets the bytecode and argument at pos to op and arg respectivly. + @exception ArrayIndexOutOfBoundException if pos < 0 || pos >= size() + */ + public final void set(int pos, byte op, Object arg) { + switch(op) { + case ILOAD: case ISTORE: case LLOAD: case LSTORE: case FLOAD: + case FSTORE: case DLOAD: case DSTORE: case ALOAD: case ASTORE: + // set(int,byte,int) always handles these ops itself + set(pos,op,((Integer)arg).intValue()); + return; case LDC: - if(arg instanceof Integer) { set(pos,op,iarg); return; } + // set(int,byte,int) always handles these opts itself + if(arg instanceof Integer) { set(pos,op,((Integer)arg).intValue()); return; } if(arg instanceof Boolean) { set(pos,op,((Boolean)arg).booleanValue()); return; } + if(arg instanceof Long) { long l = ((Long)arg).longValue(); - if(l == 0L) { set(pos,LCONST_0); return; } - if(l == 1L) { set(pos,LCONST_1); return; } + if(l == 0L) { this.op[pos] = LCONST_0; return; } + if(l == 1L) { this.op[pos] = LCONST_1; return; } } if(arg instanceof Long || arg instanceof Double) op = LDC2_W; - // fall through - default: - if(OP_CPENT(op) && !(arg instanceof CPGen.Ent)) arg = cp.add(arg); + break; + case INVOKEINTERFACE: + if(arg instanceof MethodRef) arg = new MethodRef.I((MethodRef)arg); break; } - _set(pos,op,arg); - } - - private final void _set(int pos, byte op, Object arg) { - if(capacity == -1) throw new IllegalStateException("method can't have code"); - if(size == -1) throw new IllegalStateException("method is finalized"); - if(!OP_VALID(op)) throw new IllegalArgumentException("unknown bytecode"); - + int opdata = OP_DATA[op&0xff]; + if((opdata&OP_CPENT_FLAG) != 0 && !(arg instanceof CPGen.Ent)) + arg = cp.add(arg); + else if((opdata&OP_VALID_FLAG) == 0) + throw new IllegalArgumentException("unknown bytecode"); this.op[pos] = op; this.arg[pos] = arg; } + /** This class represents the arguments to the TABLESWITH and LOOKUPSWITCH bytecodes + @see MethodGen.TSI + @see MethodGen.LSI + */ public static class SI { public final Object[] targets; public Object defaultTarget; @@ -192,13 +273,13 @@ public class MethodGen implements CGConst { public int size() { return targets.length; } public int getTarget(int pos) { return ((Integer)targets[pos]).intValue(); } - public int getDefaultTarget() { return ((Integer)defaultTarget).intValue(); } + public int getDefaultTarget() { return ((Integer)defaultTarget).intValue(); } } + /** This class represents the arguments to the TABLESWITCH bytecode */ public static class TSI extends SI { public final int lo; public final int hi; - public int defaultTarget = -1; public TSI(int lo, int hi) { super(hi-lo+1); this.lo = lo; @@ -208,6 +289,7 @@ public class MethodGen implements CGConst { public void setTargetForVal(int val, int n) { setTarget(val-lo,n); } } + /** This class represents the arguments to the LOOKUPSWITCH bytecode */ public static class LSI extends SI { public final int[] vals; public LSI(int size) { @@ -217,15 +299,23 @@ public class MethodGen implements CGConst { public final void setVal(int pos, int val) { vals[pos] = val; } } + /** This class represents the arguments to byecodes that take two integer arguments. */ public static class Pair { public int i1; public int i2; public Pair(int i1, int i2) { this.i1 = i1; this.i2 = i2; } } + /** Sets the maximum number of locals in the function to maxLocals. NOTE: This defaults to 0 and is automatically increased as + necessary when *LOAD/*STORE bytecodes are added. You do not need to call this function in most cases */ public void setMaxLocals(int maxLocals) { this.maxLocals = maxLocals; } + /** Sets the maxinum size of th stack for this function to maxStack. This defaults to 16< */ public void setMaxStack(int maxStack) { this.maxStack = maxStack; } + /** Computes the final bytecode for this method. + @exception IllegalStateException if the data for a method is in an inconsistent state (required arguments missing, etc) + @exception Exn if the byteocode could not be generated for any other reason (constant pool full, etc) + */ public void finish() { try { _finish(); @@ -249,7 +339,7 @@ public class MethodGen implements CGConst { } private void _finish() throws IOException { - if(size == -1) return; + if(size == FINISHED) return; ByteArrayOutputStream baos = new ByteArrayOutputStream(); DataOutput o = new DataOutputStream(baos); @@ -261,10 +351,11 @@ public class MethodGen implements CGConst { // Pass1 - Calculate maximum pc of each bytecode, widen some insns, resolve any unresolved jumps, etc for(i=0,p=0;i= 256) this.op[i] = op = LDC_W; // fall through default: - if((j = OP_ARG_SIZE(op)) == -1) throw new Error("shouldn't be here"); + if((j = (opdata&OP_ARG_LENGTH_MASK)) == 7) throw new Error("shouldn't be here"); p += 1 + j; break; } @@ -328,7 +425,7 @@ public class MethodGen implements CGConst { case TABLESWITCH: case LOOKUPSWITCH: { SI si = (SI) arg[i]; - p++; // opcpde itself + p++; // opcode itself p = (p + 3) & ~3; // padding p += 4; // default if(op == TABLESWITCH) p += 4 + 4 + si.size() * 4; // lo, hi, targets @@ -336,8 +433,8 @@ public class MethodGen implements CGConst { break; } default: { - int l = OP_ARG_SIZE(op); - if(l == -1) throw new Error("shouldn't be here"); + int l = OP_DATA[op&0xff] & OP_ARG_LENGTH_MASK; + if(l == 7) throw new Error("shouldn't be here"); p += 1 + l; } } @@ -345,6 +442,8 @@ public class MethodGen implements CGConst { int codeSize = p; + if(codeSize >= 65536) throw new ClassGen.Exn("method too large in size"); + o.writeShort(maxStack); o.writeShort(maxLocals); o.writeInt(codeSize); @@ -352,17 +451,16 @@ public class MethodGen implements CGConst { // Pass 4 - Actually write the bytecodes for(i=0;i 255 || pair.i2 < -128 || pair.i2 > 127) throw new ClassGen.Exn("overflow of iinc arg"); o.writeByte(pair.i1); o.writeByte(pair.i2); + break; } case TABLESWITCH: case LOOKUPSWITCH: { @@ -392,26 +491,34 @@ public class MethodGen implements CGConst { } break; } + case WIDE: + throw new Error("WIDE instruction not yet supported"); default: - if(OP_BRANCH(op)) { - int v = pc[iarg] - pc[i]; - if(v < -32768 || v > 32767) throw new ClassGen.Exn("overflow of s2 offset"); - o.writeShort(v); - } else if(OP_CPENT(op)) { + if((opdata & OP_BRANCH_FLAG) != 0) { + int v = pc[((Integer)arg).intValue()] - pc[i]; + if(argLength == 2) { + if(v < -32768 || v > 32767) throw new ClassGen.Exn("overflow of s2 offset"); + o.writeShort(v); + } else if(argLength == 4) { + o.writeInt(v); + } else { + throw new Error("should never happen"); + } + } else if((opdata & OP_CPENT_FLAG) != 0) { int v = ((CPGen.Ent)arg).getIndex(); if(argLength == 1) o.writeByte(v); else if(argLength == 2) o.writeShort(v); else throw new Error("should never happen"); - } else if(argLength == -1) { + } else if(argLength == 7) { throw new Error("should never happen - variable length instruction not explicitly handled"); } else { - if(!wasInt) throw new IllegalStateException("Invalid argument given for " + Integer.toHexString(op&0xff)); + int iarg = ((Integer)arg).intValue(); if(argLength == 1) { if(iarg < -128 || iarg >= 256) throw new ClassGen.Exn("overflow of s/u1 option"); o.writeByte(iarg); } else if(argLength == 2) { - if(iarg < -32767 || iarg >= 65536) throw new ClassGen.Exn("overflow of s/u2 option"); + if(iarg < -32768 || iarg >= 65536) throw new ClassGen.Exn("overflow of s/u2 option"); o.writeShort(iarg); } else { throw new Error("should never happen"); @@ -421,7 +528,7 @@ public class MethodGen implements CGConst { } } - if(baos.size() - 8 != codeSize) throw new Error("we didn't output what we were supposed to"); + //if(baos.size() - 8 != codeSize) throw new Error("we didn't output what we were supposed to"); o.writeShort(exnTable.size()); for(Enumeration e = exnTable.keys();e.hasMoreElements();) @@ -441,10 +548,10 @@ public class MethodGen implements CGConst { o.writeShort(((CPGen.Ent)thrownExceptions.get(e.nextElement())).getIndex()); attrs.add("Exceptions",baos.toByteArray()); - size = -1; + size = capacity = FINISHED; } - public void dump(DataOutput o) throws IOException { + void dump(DataOutput o) throws IOException { o.writeShort(flags); o.writeShort(cp.getUtf8Index(name)); o.writeShort(cp.getUtf8Index(getDescriptor())); @@ -452,6 +559,8 @@ public class MethodGen implements CGConst { attrs.dump(o); } + /** Negates the IF* instruction, op (IF_ICMPGT -> IF_ICMPLE, IFNE -> IFEQ, etc) + @exception IllegalArgumentException if op isn't an IF* instruction */ public static byte negate(byte op) { switch(op) { case IFEQ: return IFNE; @@ -474,6 +583,8 @@ public class MethodGen implements CGConst { } } + /** Class that represents a target that isn't currently know. The target MUST be set with setTarget() before the classfile is written. + This class is more or less a mutable integer */ public static class PhantomTarget { private int target = -1; public void setTarget(int target) { this.target = target; } @@ -486,28 +597,32 @@ public class MethodGen implements CGConst { private static Double N(double d) { return new Double(d); } private static int max(int a, int b) { return a > b ? a : b; } - private static final boolean OP_VALID(byte op) { return (OP_DATA[op&0xff] & 1) != 0; } - private static final int OP_ARG_SIZE(byte op) { int n = ((OP_DATA[op&0xff]>>1)&3); return n == 7 ? -1 : n; } - private static final boolean OP_CPENT(byte op) { return (OP_DATA[op&0xff]&(1<<4)) != 0; } - private static final boolean OP_BRANCH(byte op) { return (OP_DATA[op&0xff]&(1<<5)) != 0; } + private static final int OP_BRANCH_FLAG = 1<<3; + private static final int OP_CPENT_FLAG = 1<<4; + private static final int OP_VALID_FLAG = 1<<5; + private static final int OP_ARG_LENGTH_MASK = 7; + private static final boolean OP_VALID(byte op) { return (OP_DATA[op&0xff] & OP_VALID_FLAG) != 0; } + private static final int OP_ARG_LENGTH(byte op) { return (OP_DATA[op&0xff]&OP_ARG_LENGTH_MASK); } + private static final boolean OP_CPENT(byte op) { return (OP_DATA[op&0xff]&OP_CPENT_FLAG) != 0; } + private static final boolean OP_BRANCH(byte op) { return (OP_DATA[op&0xff]&OP_BRANCH_FLAG ) != 0; } // Run perl -x src/org/ibex/classgen/CGConst.java to generate this private static final byte[] OP_DATA = { - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x03, 0x05, 0x13, 0x15, 0x15, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x21, 0x22, 0x31, 0x32, 0x32, 0x21, 0x21, 0x21, 0x21, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x22, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, + 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x21, 0x27, 0x27, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x01, 0x32, 0x21, 0x32, 0x20, 0x20, + 0x32, 0x32, 0x20, 0x20, 0x27, 0x23, 0x2a, 0x2a, 0x2c, 0x2c, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, - 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x03, 0x0f, 0x0f, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x02, 0x15, 0x03, 0x15, 0x01, 0x01, - 0x15, 0x15, 0x01, 0x01, 0x0f, 0x07, 0x25, 0x25, 0x29, 0x29, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, - 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, - 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, - 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02 + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }; }