private static Vector3 DecryptVector3Value(string key, string encryptedInput, Vector3 defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string str = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (str == string.Empty)
{
return(defaultValue);
}
string[] strArray = str.Split("|"[0]);
float result1;
float.TryParse(strArray[0], out result1);
float result2;
float.TryParse(strArray[1], out result2);
float result3;
float.TryParse(strArray[2], out result3);
Vector3 vector3;
// ISSUE: explicit reference operation
((Vector3)@vector3).\u002Ector(result1, result2, result3);
ObscuredPrefs.SetVector3(key, vector3);
return(vector3);
}
byte[] numArray = ObscuredPrefs.DecryptData(key, encryptedInput);
if (numArray == null)
{
return(defaultValue);
}
Vector3 vector3_1;
vector3_1.x = (__Null)(double)BitConverter.ToSingle(numArray, 0);
vector3_1.y = (__Null)(double)BitConverter.ToSingle(numArray, 4);
vector3_1.z = (__Null)(double)BitConverter.ToSingle(numArray, 8);
return(vector3_1);
}
private static Vector2 DecryptVector2Value(string key, string encryptedInput, Vector2 defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string text = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (text == string.Empty)
{
return(defaultValue);
}
string[] array = text.Split(new char[]
{
"|"[0]
});
float x;
float.TryParse(array[0], out x);
float y;
float.TryParse(array[1], out y);
Vector2 vector = new Vector2(x, y);
ObscuredPrefs.SetVector2(key, vector);
return(vector);
}
else
{
byte[] array2 = ObscuredPrefs.DecryptData(key, encryptedInput);
if (array2 == null)
{
return(defaultValue);
}
Vector2 result;
result.x = BitConverter.ToSingle(array2, 0);
result.y = BitConverter.ToSingle(array2, 4);
return(result);
}
}
private static byte[] DecryptByteArrayValue(string key, string encryptedInput, byte defaultValue, int defaultLength)
{
if (encryptedInput.IndexOf(':') <= -1)
{
return(ObscuredPrefs.DecryptData(key, encryptedInput) ?? ObscuredPrefs.ConstructByteArray(defaultValue, defaultLength));
}
string s = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (s == string.Empty)
{
return(ObscuredPrefs.ConstructByteArray(defaultValue, defaultLength));
}
byte[] bytes = Encoding.UTF8.GetBytes(s);
ObscuredPrefs.SetByteArray(key, bytes);
return(bytes);
}
private static string DecryptStringValue(string key, string encryptedInput, string defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string str = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (str == string.Empty)
{
return(defaultValue);
}
ObscuredPrefs.SetString(key, str);
return(str);
}
byte[] bytes = ObscuredPrefs.DecryptData(key, encryptedInput);
if (bytes == null)
{
return(defaultValue);
}
return(Encoding.UTF8.GetString(bytes, 0, bytes.Length));
}
private static Rect DecryptRectValue(string key, string encryptedInput, Rect defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string text = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (text == string.Empty)
{
return(defaultValue);
}
string[] array = text.Split(new char[]
{
"|"[0]
});
float x;
float.TryParse(array[0], out x);
float y;
float.TryParse(array[1], out y);
float width;
float.TryParse(array[2], out width);
float height;
float.TryParse(array[3], out height);
Rect rect = new Rect(x, y, width, height);
ObscuredPrefs.SetRect(key, rect);
return(rect);
}
else
{
byte[] array2 = ObscuredPrefs.DecryptData(key, encryptedInput);
if (array2 == null)
{
return(defaultValue);
}
return(new Rect
{
x = BitConverter.ToSingle(array2, 0),
y = BitConverter.ToSingle(array2, 4),
width = BitConverter.ToSingle(array2, 8),
height = BitConverter.ToSingle(array2, 12)
});
}
}
private static Rect DecryptRectValue(string key, string encryptedInput, Rect defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string str = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (str == string.Empty)
{
return(defaultValue);
}
string[] strArray = str.Split("|"[0]);
float result1;
float.TryParse(strArray[0], out result1);
float result2;
float.TryParse(strArray[1], out result2);
float result3;
float.TryParse(strArray[2], out result3);
float result4;
float.TryParse(strArray[3], out result4);
Rect rect;
// ISSUE: explicit reference operation
((Rect)@rect).\u002Ector(result1, result2, result3, result4);
ObscuredPrefs.SetRect(key, rect);
return(rect);
}
byte[] numArray = ObscuredPrefs.DecryptData(key, encryptedInput);
if (numArray == null)
{
return(defaultValue);
}
Rect rect1 = (Rect)null;
// ISSUE: explicit reference operation
((Rect)@rect1).set_x(BitConverter.ToSingle(numArray, 0));
// ISSUE: explicit reference operation
((Rect)@rect1).set_y(BitConverter.ToSingle(numArray, 4));
// ISSUE: explicit reference operation
((Rect)@rect1).set_width(BitConverter.ToSingle(numArray, 8));
// ISSUE: explicit reference operation
((Rect)@rect1).set_height(BitConverter.ToSingle(numArray, 12));
return(rect1);
}
private static double DecryptDoubleValue(string key, string encryptedInput, double defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string s = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (s == string.Empty)
{
return(defaultValue);
}
double result;
double.TryParse(s, out result);
ObscuredPrefs.SetDouble(key, result);
return(result);
}
byte[] numArray = ObscuredPrefs.DecryptData(key, encryptedInput);
if (numArray == null)
{
return(defaultValue);
}
return(BitConverter.ToDouble(numArray, 0));
}
private static float DecryptFloatValue(string key, string encryptedInput, float defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string s = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (s == string.Empty)
{
return(defaultValue);
}
float result;
float.TryParse(s, out result);
ObscuredPrefs.SetFloat(key, result);
return(result);
}
byte[] numArray = ObscuredPrefs.DecryptData(key, encryptedInput);
if (numArray == null)
{
return(defaultValue);
}
return(BitConverter.ToSingle(numArray, 0));
}
private static long DecryptLongValue(string key, string encryptedInput, long defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string s = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (s == string.Empty)
{
return(defaultValue);
}
long result;
long.TryParse(s, out result);
ObscuredPrefs.SetLong(key, result);
return(result);
}
byte[] numArray = ObscuredPrefs.DecryptData(key, encryptedInput);
if (numArray == null)
{
return(defaultValue);
}
return(BitConverter.ToInt64(numArray, 0));
}
private static bool DecryptBoolValue(string key, string encryptedInput, bool defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string s = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (s == string.Empty)
{
return(defaultValue);
}
int result;
int.TryParse(s, out result);
ObscuredPrefs.SetBool(key, result == 1);
return(result == 1);
}
byte[] numArray = ObscuredPrefs.DecryptData(key, encryptedInput);
if (numArray == null)
{
return(defaultValue);
}
return(BitConverter.ToBoolean(numArray, 0));
}
private static Quaternion DecryptQuaternionValue(string key, string encryptedInput, Quaternion defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string text = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (text == string.Empty)
{
return(defaultValue);
}
string[] array = text.Split(new char[]
{
"|"[0]
});
float x;
float.TryParse(array[0], out x);
float y;
float.TryParse(array[1], out y);
float z;
float.TryParse(array[2], out z);
float w;
float.TryParse(array[3], out w);
Quaternion quaternion = new Quaternion(x, y, z, w);
ObscuredPrefs.SetQuaternion(key, quaternion);
return(quaternion);
}
else
{
byte[] array2 = ObscuredPrefs.DecryptData(key, encryptedInput);
if (array2 == null)
{
return(defaultValue);
}
Quaternion result;
result.x = BitConverter.ToSingle(array2, 0);
result.y = BitConverter.ToSingle(array2, 4);
result.z = BitConverter.ToSingle(array2, 8);
result.w = BitConverter.ToSingle(array2, 12);
return(result);
}
}
internal static string DecryptStringValue(string key, string encryptedInput, string defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string text = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (text == string.Empty)
{
return(defaultValue);
}
ObscuredPrefs.SetString(key, text);
return(text);
}
else
{
byte[] array = ObscuredPrefs.DecryptData(key, encryptedInput);
if (array == null)
{
return(defaultValue);
}
return(Encoding.UTF8.GetString(array, 0, array.Length));
}
}
private static byte[] DecryptByteArrayValue(string key, string encryptedInput, byte defaultValue, int defaultLength)
{
if (encryptedInput.IndexOf(':') > -1)
{
string text = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (text == string.Empty)
{
return(ObscuredPrefs.ConstructByteArray(defaultValue, defaultLength));
}
byte[] bytes = Encoding.UTF8.GetBytes(text);
ObscuredPrefs.SetByteArray(key, bytes);
return(bytes);
}
else
{
byte[] array = ObscuredPrefs.DecryptData(key, encryptedInput);
if (array == null)
{
return(ObscuredPrefs.ConstructByteArray(defaultValue, defaultLength));
}
return(array);
}
}
private static Quaternion DecryptQuaternionValue(string key, string encryptedInput, Quaternion defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string str = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (str == string.Empty)
{
return(defaultValue);
}
string[] strArray = str.Split("|"[0]);
float result1;
float.TryParse(strArray[0], out result1);
float result2;
float.TryParse(strArray[1], out result2);
float result3;
float.TryParse(strArray[2], out result3);
float result4;
float.TryParse(strArray[3], out result4);
Quaternion quaternion;
// ISSUE: explicit reference operation
((Quaternion)@quaternion).\u002Ector(result1, result2, result3, result4);
ObscuredPrefs.SetQuaternion(key, quaternion);
return(quaternion);
}
byte[] numArray = ObscuredPrefs.DecryptData(key, encryptedInput);
if (numArray == null)
{
return(defaultValue);
}
Quaternion quaternion1;
quaternion1.x = (__Null)(double)BitConverter.ToSingle(numArray, 0);
quaternion1.y = (__Null)(double)BitConverter.ToSingle(numArray, 4);
quaternion1.z = (__Null)(double)BitConverter.ToSingle(numArray, 8);
quaternion1.w = (__Null)(double)BitConverter.ToSingle(numArray, 12);
return(quaternion1);
}
private static uint DecryptUIntValue(string key, string encryptedInput, uint defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string text = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (text == string.Empty)
{
return(defaultValue);
}
uint num;
uint.TryParse(text, out num);
ObscuredPrefs.SetUInt(key, num);
return(num);
}
else
{
byte[] array = ObscuredPrefs.DecryptData(key, encryptedInput);
if (array == null)
{
return(defaultValue);
}
return(BitConverter.ToUInt32(array, 0));
}
}
private static bool DecryptBoolValue(string key, string encryptedInput, bool defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string text = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (text == string.Empty)
{
return(defaultValue);
}
int num;
int.TryParse(text, out num);
ObscuredPrefs.SetBool(key, num == 1);
return(num == 1);
}
else
{
byte[] array = ObscuredPrefs.DecryptData(key, encryptedInput);
if (array == null)
{
return(defaultValue);
}
return(BitConverter.ToBoolean(array, 0));
}
}
private static long DecryptLongValue(string key, string encryptedInput, long defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string text = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (text == string.Empty)
{
return(defaultValue);
}
long num;
long.TryParse(text, out num);
ObscuredPrefs.SetLong(key, num);
return(num);
}
else
{
byte[] array = ObscuredPrefs.DecryptData(key, encryptedInput);
if (array == null)
{
return(defaultValue);
}
return(BitConverter.ToInt64(array, 0));
}
}
private static double DecryptDoubleValue(string key, string encryptedInput, double defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string text = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (text == string.Empty)
{
return(defaultValue);
}
double num;
double.TryParse(text, out num);
ObscuredPrefs.SetDouble(key, num);
return(num);
}
else
{
byte[] array = ObscuredPrefs.DecryptData(key, encryptedInput);
if (array == null)
{
return(defaultValue);
}
return(BitConverter.ToDouble(array, 0));
}
}
internal static float DecryptFloatValue(string key, string encryptedInput, float defaultValue)
{
if (encryptedInput.IndexOf(':') > -1)
{
string text = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput);
if (text == string.Empty)
{
return(defaultValue);
}
float num;
float.TryParse(text, out num);
ObscuredPrefs.SetFloat(key, num);
return(num);
}
else
{
byte[] array = ObscuredPrefs.DecryptData(key, encryptedInput);
if (array == null)
{
return(defaultValue);
}
return(BitConverter.ToSingle(array, 0));
}
}
