mirror of
https://github.com/johndoe6345789/tustu.git
synced 2026-04-25 06:04:59 +00:00
603 lines
22 KiB
Java
603 lines
22 KiB
Java
package bH;
|
|
|
|
import java.math.BigInteger;
|
|
import java.util.ArrayList;
|
|
import java.util.StringTokenizer;
|
|
|
|
public class c {
|
|
private static final int[] a = new int[] {
|
|
1, 2, 4, 8, 16, 32, 64, 128, 256, 512,
|
|
1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288,
|
|
1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912,
|
|
1073741824, Integer.MIN_VALUE };
|
|
|
|
private static final long[] b = new long[] {
|
|
1L, 2L, 4L, 8L, 16L, 32L, 64L, 128L, 256L, 512L,
|
|
1024L, 2048L, 4096L, 8192L, 16384L, 32768L, 65536L, 131072L, 262144L, 524288L,
|
|
1048576L, 2097152L, 4194304L, 8388608L, 16777216L, 33554432L, 67108864L, 134217728L, 268435456L, 536870912L,
|
|
1073741824L, -2147483648L, 4294967296L, 8589934592L, 17179869184L, 34359738368L, 68719476736L, 137438953472L, 274877906944L, 549755813888L,
|
|
1099511627776L, 2199023255552L, 4398046511104L, 8796093022208L, 17592186044416L, 35184372088832L, 70368744177664L, 140737488355328L, 281474976710656L, 562949953421312L,
|
|
1125899906842624L, 2251799813685248L, 4503599627370496L, 9007199254740992L, 18014398509481984L, 36028797018963968L, 72057594037927936L, 144115188075855872L, 288230376151711744L, 576460752303423488L,
|
|
1152921504606846976L, 2305843009213693952L, 4611686018427387904L, Long.MIN_VALUE };
|
|
|
|
public static boolean a(byte[] paramArrayOfbyte) {
|
|
if (paramArrayOfbyte != null) {
|
|
for (byte b = 0; b < paramArrayOfbyte.length; b++) {
|
|
byte b1 = paramArrayOfbyte[b];
|
|
if (!a(b1))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static boolean a(ArrayList paramArrayList) {
|
|
for (Byte byte_ : paramArrayList) {
|
|
if (byte_.intValue() < 9 || byte_.byteValue() > 126)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static boolean a(int paramInt) {
|
|
return ((paramInt >= 32 && paramInt <= 126) || paramInt == 9 || paramInt == 10);
|
|
}
|
|
|
|
public static byte[] a(int[] paramArrayOfint) {
|
|
byte[] arrayOfByte = new byte[paramArrayOfint.length];
|
|
for (byte b = 0; b < paramArrayOfint.length; b++)
|
|
arrayOfByte[b] = (byte)paramArrayOfint[b];
|
|
return arrayOfByte;
|
|
}
|
|
|
|
public static int[] b(byte[] paramArrayOfbyte) {
|
|
int[] arrayOfInt = new int[paramArrayOfbyte.length];
|
|
for (byte b = 0; b < arrayOfInt.length; b++)
|
|
arrayOfInt[b] = a(paramArrayOfbyte[b]);
|
|
return arrayOfInt;
|
|
}
|
|
|
|
public static int a(int paramInt1, int paramInt2, int paramInt3) {
|
|
int i = a(paramInt2, paramInt3);
|
|
int j = paramInt1 & i;
|
|
return j >>> paramInt2;
|
|
}
|
|
|
|
public static long a(long paramLong, int paramInt1, int paramInt2) {
|
|
long l1 = a(paramInt1, paramInt2);
|
|
long l2 = paramLong & l1;
|
|
return l2 >>> paramInt1;
|
|
}
|
|
|
|
public static byte[] c(byte[] paramArrayOfbyte) {
|
|
for (byte b = 0; b < paramArrayOfbyte.length; b++) {
|
|
if (paramArrayOfbyte[b] == 0) {
|
|
byte[] arrayOfByte = new byte[b];
|
|
System.arraycopy(paramArrayOfbyte, 0, arrayOfByte, 0, arrayOfByte.length);
|
|
paramArrayOfbyte = arrayOfByte;
|
|
break;
|
|
}
|
|
}
|
|
return paramArrayOfbyte;
|
|
}
|
|
|
|
public static String a(String paramString) {
|
|
boolean bool = false;
|
|
for (byte b = 0; b < paramString.length(); b++) {
|
|
if ((paramString.charAt(b) < ' ' || paramString.charAt(b) > '~') && paramString.charAt(b) != '\t') {
|
|
bool = true;
|
|
break;
|
|
}
|
|
}
|
|
if (bool) {
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for (byte b1 = 0; b1 < paramString.length(); b1++) {
|
|
if (paramString.charAt(b1) < ' ' || paramString.charAt(b1) > '~') {
|
|
stringBuilder.append('.');
|
|
} else {
|
|
stringBuilder.append(paramString.charAt(b1));
|
|
}
|
|
}
|
|
return stringBuilder.toString();
|
|
}
|
|
return paramString;
|
|
}
|
|
|
|
public static int[] b(String paramString) {
|
|
if (paramString.contains(",")) {
|
|
arrayOfString = paramString.split(",");
|
|
} else {
|
|
arrayOfString = paramString.split(" ");
|
|
}
|
|
ArrayList<String> arrayList = new ArrayList();
|
|
for (String str : arrayOfString) {
|
|
if (!str.contains(".") && str.length() > 1 && str.length() < 5)
|
|
arrayList.add(str);
|
|
}
|
|
String[] arrayOfString = arrayList.<String>toArray(new String[arrayList.size()]);
|
|
return a(arrayOfString);
|
|
}
|
|
|
|
public static int[] a(String[] paramArrayOfString) {
|
|
int[] arrayOfInt = new int[paramArrayOfString.length];
|
|
for (byte b = 0; b < paramArrayOfString.length; b++) {
|
|
if (paramArrayOfString[b].startsWith("0x") || paramArrayOfString[b].startsWith("x")) {
|
|
paramArrayOfString[b] = X.b(paramArrayOfString[b], "0x", "");
|
|
paramArrayOfString[b] = X.b(paramArrayOfString[b], "x", "");
|
|
arrayOfInt[b] = Integer.parseInt(paramArrayOfString[b], 16);
|
|
} else {
|
|
arrayOfInt[b] = Integer.parseInt(paramArrayOfString[b]);
|
|
}
|
|
}
|
|
return arrayOfInt;
|
|
}
|
|
|
|
public static byte[] a(Byte[] paramArrayOfByte) {
|
|
byte[] arrayOfByte = new byte[paramArrayOfByte.length];
|
|
for (byte b = 0; b < arrayOfByte.length; b++)
|
|
arrayOfByte[b] = paramArrayOfByte[b].byteValue();
|
|
return arrayOfByte;
|
|
}
|
|
|
|
public static byte[] c(String paramString) {
|
|
StringTokenizer stringTokenizer = new StringTokenizer(paramString, ",");
|
|
byte[] arrayOfByte = new byte[stringTokenizer.countTokens()];
|
|
for (byte b = 0; stringTokenizer.hasMoreTokens(); b++)
|
|
arrayOfByte[b] = Byte.parseByte(stringTokenizer.nextToken());
|
|
return arrayOfByte;
|
|
}
|
|
|
|
public static BigInteger a(int[] paramArrayOfint, int paramInt1, int paramInt2, boolean paramBoolean1, boolean paramBoolean2) {
|
|
if (!paramBoolean1) {
|
|
int[] arrayOfInt = new int[paramInt2];
|
|
for (byte b1 = 0; b1 < paramInt2; b1++)
|
|
arrayOfInt[arrayOfInt.length - 1 - b1] = paramArrayOfint[paramInt1 + b1];
|
|
paramArrayOfint = arrayOfInt;
|
|
paramInt1 = 0;
|
|
}
|
|
byte[] arrayOfByte = new byte[paramInt2];
|
|
for (byte b = 0; b < paramInt2; b++)
|
|
arrayOfByte[b] = (byte)paramArrayOfint[paramInt1 + b];
|
|
return new BigInteger(arrayOfByte);
|
|
}
|
|
|
|
public static byte[] a(byte[] paramArrayOfbyte1, byte[] paramArrayOfbyte2) {
|
|
if (paramArrayOfbyte1.length == 0)
|
|
return paramArrayOfbyte2;
|
|
if (paramArrayOfbyte2.length == 0)
|
|
return paramArrayOfbyte1;
|
|
byte[] arrayOfByte = new byte[paramArrayOfbyte1.length + paramArrayOfbyte2.length];
|
|
System.arraycopy(paramArrayOfbyte1, 0, arrayOfByte, 0, paramArrayOfbyte1.length);
|
|
System.arraycopy(paramArrayOfbyte2, 0, arrayOfByte, paramArrayOfbyte1.length, paramArrayOfbyte2.length);
|
|
return arrayOfByte;
|
|
}
|
|
|
|
public static byte[] a(byte[] paramArrayOfbyte, int paramInt1, int paramInt2, int paramInt3, boolean paramBoolean) {
|
|
byte[] arrayOfByte = new byte[paramInt3];
|
|
arrayOfByte = a(paramInt1, arrayOfByte, paramBoolean);
|
|
for (int i = paramInt2; i < paramArrayOfbyte.length && i < paramInt2 + paramInt3; i++)
|
|
paramArrayOfbyte[i] = arrayOfByte[i - paramInt2];
|
|
return paramArrayOfbyte;
|
|
}
|
|
|
|
public static byte[] a(byte[] paramArrayOfbyte, byte paramByte) {
|
|
for (byte b = 0; b < paramArrayOfbyte.length; b++)
|
|
paramArrayOfbyte[b] = paramByte;
|
|
return paramArrayOfbyte;
|
|
}
|
|
|
|
public static int b(int[] paramArrayOfint, int paramInt1, int paramInt2, boolean paramBoolean1, boolean paramBoolean2) {
|
|
return a(paramArrayOfint, paramInt1, paramInt2, 0, paramBoolean1, paramBoolean2);
|
|
}
|
|
|
|
public static int a(int[] paramArrayOfint, int paramInt1, int paramInt2, int paramInt3, boolean paramBoolean1, boolean paramBoolean2) {
|
|
int i = 0;
|
|
if (!paramBoolean1) {
|
|
int[] arrayOfInt = new int[paramInt2];
|
|
for (byte b = 0; b < paramInt2; b++)
|
|
arrayOfInt[arrayOfInt.length - 1 - b] = paramArrayOfint[paramInt1 + b];
|
|
paramArrayOfint = arrayOfInt;
|
|
paramInt1 = 0;
|
|
}
|
|
int j;
|
|
for (j = 0; j < paramInt2; j++) {
|
|
int k = paramArrayOfint[paramInt1 + j] << (paramInt2 - j - 1) * 8;
|
|
i += k;
|
|
}
|
|
if (paramBoolean2 && (paramArrayOfint[paramInt1] | 0x80) == paramArrayOfint[paramInt1]) {
|
|
i += paramInt3;
|
|
for (j = paramInt2; j < 4; j++)
|
|
i += 255 << j * 8;
|
|
i -= paramInt3;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public static long c(int[] paramArrayOfint, int paramInt1, int paramInt2, boolean paramBoolean1, boolean paramBoolean2) {
|
|
long l = 0L;
|
|
if (!paramBoolean1) {
|
|
int[] arrayOfInt = new int[paramInt2];
|
|
for (byte b = 0; b < paramInt2; b++)
|
|
arrayOfInt[arrayOfInt.length - 1 - b] = paramArrayOfint[paramInt1 + b];
|
|
paramArrayOfint = arrayOfInt;
|
|
paramInt1 = 0;
|
|
}
|
|
int i;
|
|
for (i = 0; i < paramInt2; i++) {
|
|
long l1 = paramArrayOfint[paramInt1 + i];
|
|
l1 <<= (paramInt2 - i - 1) * 8;
|
|
l += l1;
|
|
}
|
|
if (paramBoolean2 && (paramArrayOfint[paramInt1] | 0x80) == paramArrayOfint[paramInt1])
|
|
for (i = paramInt2; i < 4; i++)
|
|
l += (255 << i * 8);
|
|
return l;
|
|
}
|
|
|
|
public static int a(byte[] paramArrayOfbyte, int paramInt1, int paramInt2, boolean paramBoolean1, boolean paramBoolean2) {
|
|
int i = 0;
|
|
if (paramInt2 == 0)
|
|
return 0;
|
|
if (!paramBoolean1) {
|
|
byte[] arrayOfByte = new byte[paramInt2];
|
|
for (byte b = 0; b < paramInt2; b++)
|
|
arrayOfByte[arrayOfByte.length - 1 - b] = paramArrayOfbyte[paramInt1 + b];
|
|
paramArrayOfbyte = arrayOfByte;
|
|
paramInt1 = 0;
|
|
}
|
|
int j;
|
|
for (j = 0; j < paramInt2; j++) {
|
|
int k = a(paramArrayOfbyte[paramInt1 + j]);
|
|
k <<= (paramInt2 - j - 1) * 8;
|
|
i += k;
|
|
}
|
|
if (paramBoolean2 && (paramArrayOfbyte[paramInt1] | 0x80) == paramArrayOfbyte[paramInt1])
|
|
for (j = paramInt2; j < 4; j++)
|
|
i += 255 << j * 8;
|
|
return i;
|
|
}
|
|
|
|
public static long b(byte[] paramArrayOfbyte, int paramInt1, int paramInt2, boolean paramBoolean1, boolean paramBoolean2) {
|
|
long l = 0L;
|
|
if (paramInt2 == 0)
|
|
return 0L;
|
|
if (!paramBoolean1) {
|
|
byte[] arrayOfByte = new byte[paramInt2];
|
|
for (byte b = 0; b < paramInt2; b++)
|
|
arrayOfByte[arrayOfByte.length - 1 - b] = paramArrayOfbyte[paramInt1 + b];
|
|
paramArrayOfbyte = arrayOfByte;
|
|
paramInt1 = 0;
|
|
}
|
|
int i;
|
|
for (i = 0; i < paramInt2; i++) {
|
|
long l1 = a(paramArrayOfbyte[paramInt1 + i]);
|
|
l1 <<= (paramInt2 - i - 1) * 8;
|
|
l += l1;
|
|
}
|
|
if (paramBoolean2 && (paramArrayOfbyte[paramInt1] | 0x80) == paramArrayOfbyte[paramInt1])
|
|
for (i = paramInt2; i < 4; i++)
|
|
l += (255 << i * 8);
|
|
return l;
|
|
}
|
|
|
|
public static byte[] a(int paramInt, byte[] paramArrayOfbyte, boolean paramBoolean) {
|
|
int i = 2147483392;
|
|
boolean bool = false;
|
|
if (paramInt < 0) {
|
|
paramInt = (paramInt ^ 0xFFFFFFFF) + 0;
|
|
bool = true;
|
|
}
|
|
byte b;
|
|
for (b = 0; b < paramArrayOfbyte.length; b++) {
|
|
paramArrayOfbyte[paramArrayOfbyte.length - b - 1] = (byte)(paramInt & (i ^ 0xFFFFFFFF));
|
|
if (bool)
|
|
paramArrayOfbyte[paramArrayOfbyte.length - b - 1] = (byte)(255 - paramArrayOfbyte[paramArrayOfbyte.length - b - 1]);
|
|
paramInt >>= 8;
|
|
}
|
|
if (!paramBoolean)
|
|
for (byte b1 = 0; b1 < paramArrayOfbyte.length / 2; b1++) {
|
|
b = paramArrayOfbyte[b1];
|
|
byte b2 = paramArrayOfbyte[paramArrayOfbyte.length - 1 - b1];
|
|
paramArrayOfbyte[b1] = b2;
|
|
paramArrayOfbyte[paramArrayOfbyte.length - 1 - b1] = b;
|
|
}
|
|
return paramArrayOfbyte;
|
|
}
|
|
|
|
public static byte[] a(long paramLong, byte[] paramArrayOfbyte, boolean paramBoolean) {
|
|
long l = 9223372036854775552L;
|
|
boolean bool = false;
|
|
if (paramLong < 0L) {
|
|
paramLong = (paramLong ^ 0xFFFFFFFFFFFFFFFFL) + 0L;
|
|
bool = true;
|
|
}
|
|
byte b;
|
|
for (b = 0; b < paramArrayOfbyte.length; b++) {
|
|
paramArrayOfbyte[paramArrayOfbyte.length - b - 1] = (byte)(int)(paramLong & (l ^ 0xFFFFFFFFFFFFFFFFL));
|
|
if (bool)
|
|
paramArrayOfbyte[paramArrayOfbyte.length - b - 1] = (byte)(255 - paramArrayOfbyte[paramArrayOfbyte.length - b - 1]);
|
|
paramLong >>= 8L;
|
|
}
|
|
if (!paramBoolean)
|
|
for (byte b1 = 0; b1 < paramArrayOfbyte.length / 2; b1++) {
|
|
b = paramArrayOfbyte[b1];
|
|
byte b2 = paramArrayOfbyte[paramArrayOfbyte.length - 1 - b1];
|
|
paramArrayOfbyte[b1] = b2;
|
|
paramArrayOfbyte[paramArrayOfbyte.length - 1 - b1] = b;
|
|
}
|
|
return paramArrayOfbyte;
|
|
}
|
|
|
|
public static int[] a(int paramInt, int[] paramArrayOfint, boolean paramBoolean) {
|
|
char c1 = 'ÿ';
|
|
for (byte b = 0; b < paramArrayOfint.length; b++) {
|
|
if (paramBoolean) {
|
|
paramArrayOfint[paramArrayOfint.length - b - 1] = paramInt & c1;
|
|
} else {
|
|
paramArrayOfint[b] = paramInt & c1;
|
|
paramArrayOfint[b] = paramArrayOfint[b];
|
|
}
|
|
paramInt >>>= 8;
|
|
}
|
|
return paramArrayOfint;
|
|
}
|
|
|
|
public static int[] a(long paramLong, int[] paramArrayOfint, boolean paramBoolean) {
|
|
long l = 255L;
|
|
for (byte b = 0; b < paramArrayOfint.length; b++) {
|
|
if (paramBoolean) {
|
|
paramArrayOfint[paramArrayOfint.length - b - 1] = (int)(paramLong & l);
|
|
} else {
|
|
paramArrayOfint[b] = (int)(paramLong & l);
|
|
paramArrayOfint[b] = paramArrayOfint[b];
|
|
}
|
|
paramLong >>>= 8L;
|
|
}
|
|
return paramArrayOfint;
|
|
}
|
|
|
|
public static String b(int[] paramArrayOfint) {
|
|
return a(paramArrayOfint, 16);
|
|
}
|
|
|
|
public static String a(int[] paramArrayOfint, int paramInt) {
|
|
if (paramArrayOfint == null)
|
|
return "null";
|
|
StringBuilder stringBuilder1 = new StringBuilder();
|
|
StringBuilder stringBuilder2 = new StringBuilder();
|
|
for (byte b = 0; b < paramArrayOfint.length; b++) {
|
|
if (paramInt > 0 && b > 0 && b % paramInt == 0) {
|
|
stringBuilder1.append(" ").append(stringBuilder2.toString()).append("\n");
|
|
stringBuilder2.delete(0, stringBuilder2.length());
|
|
}
|
|
int i = paramArrayOfint[b] & 0xFF;
|
|
String str = X.a(Integer.toHexString(i).toUpperCase(), '0', 2);
|
|
stringBuilder1.append(X.a("x" + str + " ", ' ', 4));
|
|
if (i > 32 && i < 127) {
|
|
stringBuilder2.append((char)i);
|
|
} else {
|
|
stringBuilder2.append(".");
|
|
}
|
|
}
|
|
if (stringBuilder2.length() > 0)
|
|
stringBuilder1.append(X.a(stringBuilder2.toString(), ' ', stringBuilder2.length() + 4 * paramInt + 6 - 4 * stringBuilder2.length()));
|
|
return stringBuilder1.toString();
|
|
}
|
|
|
|
public static String d(byte[] paramArrayOfbyte) {
|
|
return a(paramArrayOfbyte, 16);
|
|
}
|
|
|
|
public static String a(byte[] paramArrayOfbyte, int paramInt) {
|
|
return a(paramArrayOfbyte, paramInt, 0, paramArrayOfbyte.length);
|
|
}
|
|
|
|
public static String a(byte[] paramArrayOfbyte, int paramInt1, int paramInt2, int paramInt3) {
|
|
StringBuilder stringBuilder1 = new StringBuilder();
|
|
StringBuilder stringBuilder2 = new StringBuilder();
|
|
for (int i = paramInt2; i < paramArrayOfbyte.length && i < paramInt2 + paramInt3; i++) {
|
|
int j = a(paramArrayOfbyte[i]);
|
|
if (paramInt1 > 0 && i > 0 && i % paramInt1 == 0) {
|
|
stringBuilder1.append(" ").append(stringBuilder2).append("\n");
|
|
stringBuilder2.delete(0, stringBuilder2.length());
|
|
}
|
|
String str = X.a(Integer.toHexString(j).toUpperCase(), '0', 2);
|
|
stringBuilder1.append(X.a("x" + str + " ", ' ', 4));
|
|
if (j > 32 && j < 127) {
|
|
stringBuilder2.append((char)j);
|
|
} else {
|
|
stringBuilder2.append(".");
|
|
}
|
|
}
|
|
if (stringBuilder2.length() > 0)
|
|
stringBuilder1.append(X.a(stringBuilder2.toString(), ' ', stringBuilder2.length() + 4 * paramInt1 + 6 - 4 * stringBuilder2.length()));
|
|
return stringBuilder1.toString();
|
|
}
|
|
|
|
public static int a(byte paramByte) {
|
|
int i = paramByte;
|
|
if (i < 0)
|
|
i += 256;
|
|
return i;
|
|
}
|
|
|
|
public static String b(byte paramByte) {
|
|
return "0x" + X.a(Integer.toHexString(a(paramByte)).toUpperCase(), '0', 2);
|
|
}
|
|
|
|
public static String a(int[] paramArrayOfint1, int[] paramArrayOfint2) {
|
|
return a(0, paramArrayOfint1, paramArrayOfint2);
|
|
}
|
|
|
|
public static String a(int paramInt, int[] paramArrayOfint1, int[] paramArrayOfint2) {
|
|
String str1 = "";
|
|
String str2 = "";
|
|
String str3 = "";
|
|
byte b1 = 8;
|
|
int i = (paramArrayOfint1.length > paramArrayOfint2.length) ? paramArrayOfint1.length : paramArrayOfint2.length;
|
|
byte b2 = 0;
|
|
String str4 = "";
|
|
String str5 = "";
|
|
int j = 0;
|
|
for (byte b3 = 0; b3 < i; b3++) {
|
|
boolean bool = false;
|
|
if (paramArrayOfint1.length <= b3 || paramArrayOfint2.length <= b3 || paramArrayOfint1[b3] != paramArrayOfint2[b3]) {
|
|
bool = true;
|
|
str2 = str2 + "x" + Integer.toHexString(b3 + paramInt).toUpperCase() + ", ";
|
|
str3 = str3 + b3 + ", ";
|
|
b2++;
|
|
}
|
|
if (paramArrayOfint1.length > b3) {
|
|
int k = paramArrayOfint1[b3] & 0xFF;
|
|
String str = X.a(Integer.toHexString(k).toUpperCase(), '0', 2);
|
|
if (!bool) {
|
|
str4 = str4 + X.a(" x" + str + " ", ' ', 6);
|
|
} else {
|
|
str4 = str4 + X.a(" \"x" + str + "\"", ' ', 6);
|
|
}
|
|
} else {
|
|
str4 = str4 + X.a(" ", ' ', 6);
|
|
}
|
|
if (paramArrayOfint2.length > b3) {
|
|
int k = paramArrayOfint2[b3] & 0xFF;
|
|
String str = X.a(Integer.toHexString(k).toUpperCase(), '0', 2);
|
|
if (!bool) {
|
|
str5 = str5 + X.a(" x" + str + " ", ' ', 6);
|
|
} else {
|
|
str5 = str5 + X.a(" \"x" + str + "\"", ' ', 6);
|
|
}
|
|
} else {
|
|
str5 = str5 + X.a(" ", ' ', 6);
|
|
}
|
|
if (b3 == i - 1 || (b1 > 0 && b3 > 0 && (b3 + 1) % b1 == 0)) {
|
|
String str = "x" + X.a(Integer.toHexString(j).toUpperCase(), '0', 4);
|
|
if ((b3 + 1) % b1 != 0)
|
|
for (byte b = 0; (b3 + 1 + b) % b1 != 0; b++)
|
|
str4 = str4 + " ";
|
|
str1 = str1 + str + "\t" + str4 + "\t " + str5 + "\n";
|
|
str4 = "";
|
|
str5 = "";
|
|
j += b1;
|
|
}
|
|
}
|
|
if (b2 > 0) {
|
|
str1 = "Differences Detected at the following addresses:\n" + str2 + "\nor in Decimal:\n" + str3 + "\nNon Matching bytes in quotes:\n Set 1 Set 2\n" + str1;
|
|
} else {
|
|
str1 = "No difference detected in the following data sets:\n Set 1 Set 2\n" + str1;
|
|
}
|
|
return str1;
|
|
}
|
|
|
|
public static boolean b(int[] paramArrayOfint1, int[] paramArrayOfint2) {
|
|
if (paramArrayOfint1 == null && paramArrayOfint2 == null)
|
|
return true;
|
|
if (paramArrayOfint1 == null || paramArrayOfint2 == null)
|
|
return false;
|
|
if (paramArrayOfint1.length != paramArrayOfint2.length)
|
|
return false;
|
|
for (byte b = 0; b < paramArrayOfint1.length; b++) {
|
|
if (paramArrayOfint1[b] >= 0 && paramArrayOfint2[b] >= 0 && paramArrayOfint1[b] != paramArrayOfint2[b])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static boolean a(double[][] paramArrayOfdouble1, double[][] paramArrayOfdouble2, int paramInt, double paramDouble) {
|
|
if (paramArrayOfdouble1 == null || paramArrayOfdouble2 == null || paramArrayOfdouble1.length != paramArrayOfdouble2.length)
|
|
return false;
|
|
if (paramArrayOfdouble1.length == 0 || (paramArrayOfdouble1[0]).length == 0)
|
|
return true;
|
|
for (byte b = 0; b < paramArrayOfdouble1.length; b++) {
|
|
for (byte b1 = 0; b1 < (paramArrayOfdouble1[0]).length; b1++) {
|
|
if (paramArrayOfdouble1[b][b1] != paramArrayOfdouble2[b][b1]) {
|
|
double d1 = Math.pow(10.0D, paramInt);
|
|
double d2 = paramArrayOfdouble1[b][b1];
|
|
double d3 = paramArrayOfdouble2[b][b1];
|
|
double d4 = Math.round(Math.abs(d2 - d3) * d1) / d1;
|
|
if (d4 >= paramDouble)
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static boolean b(byte[] paramArrayOfbyte1, byte[] paramArrayOfbyte2) {
|
|
if (paramArrayOfbyte1 == null && paramArrayOfbyte2 == null)
|
|
return true;
|
|
if (paramArrayOfbyte1 == null || paramArrayOfbyte2 == null)
|
|
return false;
|
|
if (paramArrayOfbyte1.length != paramArrayOfbyte2.length)
|
|
return false;
|
|
for (byte b = 0; b < paramArrayOfbyte1.length; b++) {
|
|
if (paramArrayOfbyte1[b] != paramArrayOfbyte2[b])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static boolean c(byte[] paramArrayOfbyte1, byte[] paramArrayOfbyte2) {
|
|
if (paramArrayOfbyte1 == null || paramArrayOfbyte2 == null || paramArrayOfbyte1.length != paramArrayOfbyte2.length)
|
|
return false;
|
|
for (byte b = 0; b < paramArrayOfbyte1.length; b++) {
|
|
if (paramArrayOfbyte1[b] != paramArrayOfbyte2[b])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static boolean c(int[] paramArrayOfint1, int[] paramArrayOfint2) {
|
|
if (paramArrayOfint1 == null || paramArrayOfint2 == null || paramArrayOfint1.length != paramArrayOfint2.length)
|
|
return false;
|
|
for (byte b = 0; b < paramArrayOfint1.length; b++) {
|
|
if (paramArrayOfint1[b] != paramArrayOfint2[b])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static int a(int paramInt1, int paramInt2) {
|
|
int i = 0;
|
|
for (int j = paramInt1; j <= paramInt2; j++)
|
|
i |= a[j];
|
|
return i;
|
|
}
|
|
|
|
public static byte[] b(int paramInt) {
|
|
return new byte[] { (byte)(paramInt >>> 24), (byte)(paramInt >>> 16), (byte)(paramInt >>> 8), (byte)paramInt };
|
|
}
|
|
|
|
public static boolean e(byte[] paramArrayOfbyte) {
|
|
for (byte b = 0; b < paramArrayOfbyte.length; b++) {
|
|
if (paramArrayOfbyte[b] != 0)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static boolean c(int[] paramArrayOfint) {
|
|
for (byte b = 0; b < paramArrayOfint.length; b++) {
|
|
if (paramArrayOfint[b] != 0)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static int d(String paramString) {
|
|
byte b = 10;
|
|
if (paramString.startsWith("x")) {
|
|
paramString = paramString.substring(1);
|
|
b = 16;
|
|
} else {
|
|
b = 8;
|
|
}
|
|
return Integer.parseInt(paramString, b);
|
|
}
|
|
}
|
|
|
|
|
|
/* Location: /home/rewrich/Downloads/TunerStudioMS/TunerStudioMS/!/bH/c.class
|
|
* Java compiler version: 8 (52.0)
|
|
* JD-Core Version: 1.1.3
|
|
*/ |