From 716e68da2ad7a3e6a62fb96bd6e04384aa590780 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Thu, 17 Dec 2020 03:38:35 +0200 Subject: [PATCH 01/53] String benchmark presets Made the benchmark presets different when comparing strings --- .../Benchmark/BenchmarkData.cs | 23 ++++++++++++++++++- .../Benchmark/MenuSystem.cs | 9 ++++++-- 2 files changed, 29 insertions(+), 3 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs index 25326ea..88266f9 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs @@ -19,6 +19,20 @@ public bool IsValid benchmark2 != null; } + public bool ComparingStrings + { + get + { + if (benchmark1 == null || benchmark2 == null) return false; + else + { + return + benchmark1.typeName.Contains("String") || + benchmark2.typeName.Contains("String"); + } + } + } + public BenchmarkData(TypeInBenchmark _benchmark1, TypeInBenchmark _benchmark2, int _howMuchToIncrement, int _testsAmount) { changesAmount = _howMuchToIncrement; @@ -42,7 +56,14 @@ public BenchmarkData() public void InputPreset(BenchmarkPreset benchmarkPreset, string presetGroupName, int presetNum) { - changesAmount = benchmarkPreset.ChangesAmount; + if (ComparingStrings) + { + changesAmount = benchmarkPreset.ChangesAmount / 50; + } + else + { + changesAmount = benchmarkPreset.ChangesAmount; + } testsAmount = benchmarkPreset.TestsAmount; benchmarkPresetGroupName = presetGroupName; benchmarkPresetNumber = presetNum; diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs index 5f8e629..323f193 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs @@ -122,14 +122,19 @@ public static void DisplayBenchmarkPresetGroup(BenchmarkPresetGroup _group) for (int i = 0; i < group.presets.Length; i++) { int number = i + 1; + int changesAmount = + (currentBenchmarkData.ComparingStrings) + ? group.presets[i].ChangesAmount / 50 + : group.presets[i].ChangesAmount; + string[] lines = { "", string.Format("PRESET #{0}:", number), string.Format("-{0} Tests", group.presets[i].TestsAmount), - string.Format("-{0} Changes", group.presets[i].ChangesAmount) + string.Format("-{0} Changes", changesAmount) }; - Utilities.WriteLines(lines); + WriteLines(lines); } } From 3c3a4e11732a46b4418169a134cb9016566edfe2 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Thu, 17 Dec 2020 03:39:46 +0200 Subject: [PATCH 02/53] Revert "String benchmark presets" This reverts commit 716e68da2ad7a3e6a62fb96bd6e04384aa590780. --- .../Benchmark/BenchmarkData.cs | 23 +------------------ .../Benchmark/MenuSystem.cs | 9 ++------ 2 files changed, 3 insertions(+), 29 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs index 88266f9..25326ea 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs @@ -19,20 +19,6 @@ public bool IsValid benchmark2 != null; } - public bool ComparingStrings - { - get - { - if (benchmark1 == null || benchmark2 == null) return false; - else - { - return - benchmark1.typeName.Contains("String") || - benchmark2.typeName.Contains("String"); - } - } - } - public BenchmarkData(TypeInBenchmark _benchmark1, TypeInBenchmark _benchmark2, int _howMuchToIncrement, int _testsAmount) { changesAmount = _howMuchToIncrement; @@ -56,14 +42,7 @@ public BenchmarkData() public void InputPreset(BenchmarkPreset benchmarkPreset, string presetGroupName, int presetNum) { - if (ComparingStrings) - { - changesAmount = benchmarkPreset.ChangesAmount / 50; - } - else - { - changesAmount = benchmarkPreset.ChangesAmount; - } + changesAmount = benchmarkPreset.ChangesAmount; testsAmount = benchmarkPreset.TestsAmount; benchmarkPresetGroupName = presetGroupName; benchmarkPresetNumber = presetNum; diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs index 323f193..5f8e629 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs @@ -122,19 +122,14 @@ public static void DisplayBenchmarkPresetGroup(BenchmarkPresetGroup _group) for (int i = 0; i < group.presets.Length; i++) { int number = i + 1; - int changesAmount = - (currentBenchmarkData.ComparingStrings) - ? group.presets[i].ChangesAmount / 50 - : group.presets[i].ChangesAmount; - string[] lines = { "", string.Format("PRESET #{0}:", number), string.Format("-{0} Tests", group.presets[i].TestsAmount), - string.Format("-{0} Changes", changesAmount) + string.Format("-{0} Changes", group.presets[i].ChangesAmount) }; - WriteLines(lines); + Utilities.WriteLines(lines); } } From 48114fdfedf824488d9e8a9f91cd92618e7ae823 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Thu, 17 Dec 2020 03:39:54 +0200 Subject: [PATCH 03/53] Revert "Revert "String benchmark presets"" This reverts commit 3c3a4e11732a46b4418169a134cb9016566edfe2. --- .../Benchmark/BenchmarkData.cs | 23 ++++++++++++++++++- .../Benchmark/MenuSystem.cs | 9 ++++++-- 2 files changed, 29 insertions(+), 3 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs index 25326ea..88266f9 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs @@ -19,6 +19,20 @@ public bool IsValid benchmark2 != null; } + public bool ComparingStrings + { + get + { + if (benchmark1 == null || benchmark2 == null) return false; + else + { + return + benchmark1.typeName.Contains("String") || + benchmark2.typeName.Contains("String"); + } + } + } + public BenchmarkData(TypeInBenchmark _benchmark1, TypeInBenchmark _benchmark2, int _howMuchToIncrement, int _testsAmount) { changesAmount = _howMuchToIncrement; @@ -42,7 +56,14 @@ public BenchmarkData() public void InputPreset(BenchmarkPreset benchmarkPreset, string presetGroupName, int presetNum) { - changesAmount = benchmarkPreset.ChangesAmount; + if (ComparingStrings) + { + changesAmount = benchmarkPreset.ChangesAmount / 50; + } + else + { + changesAmount = benchmarkPreset.ChangesAmount; + } testsAmount = benchmarkPreset.TestsAmount; benchmarkPresetGroupName = presetGroupName; benchmarkPresetNumber = presetNum; diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs index 5f8e629..323f193 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs @@ -122,14 +122,19 @@ public static void DisplayBenchmarkPresetGroup(BenchmarkPresetGroup _group) for (int i = 0; i < group.presets.Length; i++) { int number = i + 1; + int changesAmount = + (currentBenchmarkData.ComparingStrings) + ? group.presets[i].ChangesAmount / 50 + : group.presets[i].ChangesAmount; + string[] lines = { "", string.Format("PRESET #{0}:", number), string.Format("-{0} Tests", group.presets[i].TestsAmount), - string.Format("-{0} Changes", group.presets[i].ChangesAmount) + string.Format("-{0} Changes", changesAmount) }; - Utilities.WriteLines(lines); + WriteLines(lines); } } From c8e5d2bd25251fa682803147d4abde87c724af91 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Thu, 17 Dec 2020 03:41:34 +0200 Subject: [PATCH 04/53] Improved EncString - Improved efficiency and performance by 30% to 40% - Changed the method for getting a random string for the encryption key --- .../Variable-Encryption/Types/EncString.cs | 38 +++++++++++++------ 1 file changed, 26 insertions(+), 12 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs index 6c4ee51..708ffb7 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs @@ -20,7 +20,7 @@ public class EncString /// private string Value { - get => EncryptorDecryptor(_encryptedValue, _encryptionKey); + get => Decrypt(); } public int Length @@ -126,7 +126,7 @@ public char this[int index] public EncString(string value) { _encryptionKey = RandomString(); - _encryptedValue = EncryptorDecryptor(value, _encryptionKey); + _encryptedValue = Encrypt(value, _encryptionKey); } public EncString(char[] value) @@ -145,24 +145,17 @@ public EncString(char[] value, int startIndex, int length) static Random random = new Random(); - static int RandomLength() => random.Next(10, 150); - - static char RandomChar(int min = char.MinValue, int max = (char.MaxValue - 1)) - { - return (char)(random.Next(min, max)); - } - static string RandomString() { - char[] chars = new char[RandomLength()]; + char[] chars = new char[random.Next(10, 100)]; // random length for (int i = 0; i < chars.Length; i++) { - chars[i] = RandomChar(); + chars[i] = (char)(random.Next(char.MinValue, char.MinValue)); // random chars } return new string(chars); } - private static string EncryptorDecryptor(string data, string key) + private static string Encrypt(string data, string key) { if (data == null) { @@ -183,6 +176,27 @@ private static string EncryptorDecryptor(string data, string key) } } + private string Decrypt() + { + if (_encryptedValue == null) + { + return null; + } + else + { + int dataLen = _encryptedValue.Length; + int keyLen = _encryptionKey.Length; + char[] output = new char[dataLen]; + + for (int i = 0; i < dataLen; ++i) + { + output[i] = (char)(_encryptedValue[i] ^ _encryptionKey[i % keyLen]); + } + + return new string(output); + } + } + #endregion #region Operators Overloading From c80d506318a46ce7945c4b49254e09fc455b3643 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Thu, 17 Dec 2020 03:43:25 +0200 Subject: [PATCH 05/53] Improved EncInt & EncLong - Added bitwise operators support - Improved efficiency and performance by 8% to 15% - Fixed a bug that could result in a data loss or an error --- .../Variable-Encryption/Types/EncInt.cs | 170 ++++++------- .../Variable-Encryption/Types/EncLong.cs | 225 +++++++++--------- 2 files changed, 203 insertions(+), 192 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs index fe2e05d..dc65089 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs @@ -8,7 +8,7 @@ public struct EncInt /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc - #region Variables And Properties + #region Variables - Properties - Methods - Constructors // The encryption values private readonly double encryptionKey1; @@ -18,22 +18,18 @@ public struct EncInt private readonly double encryptedValue; // The decrypted value - private double Value + private int Value { - get => Math.Round(Decrypt()); + get => (int)Decrypt(); } public int MaxValue { get => Int32.MaxValue; } public int MinValue { get => Int32.MinValue; } - #endregion - - #region Methods - private EncInt(double value) { - encryptionKey1 = random.NextDouble(); - encryptionKey2 = random.NextDouble(); + encryptionKey1 = random.NextDouble() * 0.001; + encryptionKey2 = random.NextDouble() * 100; encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); } @@ -41,66 +37,76 @@ private EncInt(double value) static private Random random = new Random(); // Takes a given value and returns it encrypted - private static double Encrypt(double value, double k1, double k2) => (value + k1) * k2; + private static double Encrypt(double value, double k1, double k2) => (value * k1) * k2; // Takes an encrypted value and returns it decrypted - private double Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + private double Decrypt() => ((encryptedValue / encryptionKey2) / encryptionKey1) + 0.5; // Int32 methods - public Int32 CompareTo(object value) => ((int)Value).CompareTo(value); - public Int32 CompareTo(Int32 value) => ((int)Value).CompareTo(value); - public bool Equals(Int32 obj) => ((int)Value).Equals(obj); - public override bool Equals(object obj) => ((int)Value).Equals(obj); - public override Int32 GetHashCode() => ((int)Value).GetHashCode(); - public TypeCode GetTypeCode() => ((int)Value).GetTypeCode(); - public override string ToString() => ((int)Value).ToString(); - public string ToString(IFormatProvider provider) => ((int)Value).ToString(provider); - public string ToString(string format) => ((int)Value).ToString(format); - public string ToString(string format, IFormatProvider provider) => ((int)Value).ToString(format, provider); + public Int32 CompareTo(object value) => Value.CompareTo(value); + public Int32 CompareTo(Int32 value) => Value.CompareTo(value); + public bool Equals(Int32 obj) => Value.Equals(obj); + public override bool Equals(object obj) => Value.Equals(obj); + public override Int32 GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public override string ToString() => Value.ToString(); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public string ToString(string format) => Value.ToString(format); + public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); #endregion #region Operators Overloading + /// & | ^ << >> + public static EncInt operator &(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value & eint2.Value); + public static EncInt operator |(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value | eint2.Value); + public static EncInt operator ^(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value ^ eint2.Value); + + public static int operator &(EncInt eint1, int eint2) => eint1.Value & eint2; + public static int operator |(EncInt eint1, int eint2) => eint1.Value | eint2; + public static int operator ^(EncInt eint1, int eint2) => eint1.Value ^ eint2; + public static int operator >>(EncInt eint1, int eint2) => eint1.Value >> eint2; + public static int operator <<(EncInt eint1, int eint2) => eint1.Value << eint2; + /// + - * / % - public static EncInt operator +(EncInt eint1, EncInt eint2) => new EncInt((int)Math.Round(eint1.Decrypt() + eint2.Decrypt())); - public static EncInt operator -(EncInt eint1, EncInt eint2) => new EncInt((int)Math.Round(eint1.Decrypt() - eint2.Decrypt())); - public static EncInt operator *(EncInt eint1, EncInt eint2) => new EncInt((int)Math.Round(eint1.Decrypt() * eint2.Decrypt())); - public static EncInt operator /(EncInt eint1, EncInt eint2) => new EncInt((int)Math.Round(eint1.Decrypt() / eint2.Decrypt())); - public static EncInt operator %(EncInt eint1, EncInt eint2) => new EncInt((int)Math.Round(eint1.Decrypt() % eint2.Decrypt())); - - public static int operator +(EncInt eint1, int eint2) => (int)eint1.Value + eint2; - public static int operator -(EncInt eint1, int eint2) => (int)eint1.Value - eint2; - public static int operator *(EncInt eint1, int eint2) => (int)eint1.Value * eint2; - public static int operator /(EncInt eint1, int eint2) => (int)eint1.Value / eint2; - public static int operator %(EncInt eint1, int eint2) => (int)eint1.Value % eint2; - - public static int operator +(EncInt eint1, ushort eint2) => (int)eint1.Value + eint2; - public static int operator -(EncInt eint1, ushort eint2) => (int)eint1.Value - eint2; - public static int operator *(EncInt eint1, ushort eint2) => (int)eint1.Value * eint2; - public static int operator /(EncInt eint1, ushort eint2) => (int)eint1.Value / eint2; - public static int operator %(EncInt eint1, ushort eint2) => (int)eint1.Value % eint2; - - public static int operator +(EncInt eint1, short eint2) => (int)eint1.Value + eint2; - public static int operator -(EncInt eint1, short eint2) => (int)eint1.Value - eint2; - public static int operator *(EncInt eint1, short eint2) => (int)eint1.Value * eint2; - public static int operator /(EncInt eint1, short eint2) => (int)eint1.Value / eint2; - public static int operator %(EncInt eint1, short eint2) => (int)eint1.Value % eint2; - - public static int operator +(EncInt eint1, byte eint2) => (int)eint1.Value + eint2; - public static int operator -(EncInt eint1, byte eint2) => (int)eint1.Value - eint2; - public static int operator *(EncInt eint1, byte eint2) => (int)eint1.Value * eint2; - public static int operator /(EncInt eint1, byte eint2) => (int)eint1.Value / eint2; - public static int operator %(EncInt eint1, byte eint2) => (int)eint1.Value % eint2; - - public static int operator +(EncInt eint1, sbyte eint2) => (int)eint1.Value + eint2; - public static int operator -(EncInt eint1, sbyte eint2) => (int)eint1.Value - eint2; - public static int operator *(EncInt eint1, sbyte eint2) => (int)eint1.Value * eint2; - public static int operator /(EncInt eint1, sbyte eint2) => (int)eint1.Value / eint2; - public static int operator %(EncInt eint1, sbyte eint2) => (int)eint1.Value % eint2; + public static EncInt operator +(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value + eint2.Value); + public static EncInt operator -(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value - eint2.Value); + public static EncInt operator *(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value * eint2.Value); + public static EncInt operator /(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value / eint2.Value); + public static EncInt operator %(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value % eint2.Value); + + public static int operator +(EncInt eint1, int eint2) => eint1.Value + eint2; + public static int operator -(EncInt eint1, int eint2) => eint1.Value - eint2; + public static int operator *(EncInt eint1, int eint2) => eint1.Value * eint2; + public static int operator /(EncInt eint1, int eint2) => eint1.Value / eint2; + public static int operator %(EncInt eint1, int eint2) => eint1.Value % eint2; + + public static int operator +(EncInt eint1, ushort eint2) => eint1.Value + eint2; + public static int operator -(EncInt eint1, ushort eint2) => eint1.Value - eint2; + public static int operator *(EncInt eint1, ushort eint2) => eint1.Value * eint2; + public static int operator /(EncInt eint1, ushort eint2) => eint1.Value / eint2; + public static int operator %(EncInt eint1, ushort eint2) => eint1.Value % eint2; + + public static int operator +(EncInt eint1, short eint2) => eint1.Value + eint2; + public static int operator -(EncInt eint1, short eint2) => eint1.Value - eint2; + public static int operator *(EncInt eint1, short eint2) => eint1.Value * eint2; + public static int operator /(EncInt eint1, short eint2) => eint1.Value / eint2; + public static int operator %(EncInt eint1, short eint2) => eint1.Value % eint2; + + public static int operator +(EncInt eint1, byte eint2) => eint1.Value + eint2; + public static int operator -(EncInt eint1, byte eint2) => eint1.Value - eint2; + public static int operator *(EncInt eint1, byte eint2) => eint1.Value * eint2; + public static int operator /(EncInt eint1, byte eint2) => eint1.Value / eint2; + public static int operator %(EncInt eint1, byte eint2) => eint1.Value % eint2; + + public static int operator +(EncInt eint1, sbyte eint2) => eint1.Value + eint2; + public static int operator -(EncInt eint1, sbyte eint2) => eint1.Value - eint2; + public static int operator *(EncInt eint1, sbyte eint2) => eint1.Value * eint2; + public static int operator /(EncInt eint1, sbyte eint2) => eint1.Value / eint2; + public static int operator %(EncInt eint1, sbyte eint2) => eint1.Value % eint2; /// == != < > - public static bool operator ==(EncInt eint1, EncInt eint2) => eint1.Value == eint2.Value; public static bool operator !=(EncInt eint1, EncInt eint2) => eint1.Value != eint2.Value; public static bool operator <(EncInt eint1, EncInt eint2) => eint1.Value < eint2.Value; @@ -111,20 +117,20 @@ private EncInt(double value) public static bool operator >(EncInt eint1, ulong eint2) => (ulong)eint1.Value > eint2; public static bool operator <(EncInt eint1, ulong eint2) => (ulong)eint1.Value < eint2; - public static bool operator ==(EncInt eint1, long eint2) => (long)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, long eint2) => (long)eint1.Value != eint2; - public static bool operator >(EncInt eint1, long eint2) => (long)eint1.Value > eint2; - public static bool operator <(EncInt eint1, long eint2) => (long)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, long eint2) => eint1.Value == eint2; + public static bool operator !=(EncInt eint1, long eint2) => eint1.Value != eint2; + public static bool operator >(EncInt eint1, long eint2) => eint1.Value > eint2; + public static bool operator <(EncInt eint1, long eint2) => eint1.Value < eint2; public static bool operator ==(EncInt eint1, uint eint2) => (uint)eint1.Value == eint2; public static bool operator !=(EncInt eint1, uint eint2) => (uint)eint1.Value != eint2; public static bool operator >(EncInt eint1, uint eint2) => (uint)eint1.Value > eint2; public static bool operator <(EncInt eint1, uint eint2) => (uint)eint1.Value < eint2; - public static bool operator ==(EncInt eint1, int eint2) => (int)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, int eint2) => (int)eint1.Value != eint2; - public static bool operator >(EncInt eint1, int eint2) => (int)eint1.Value > eint2; - public static bool operator <(EncInt eint1, int eint2) => (int)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, int eint2) => eint1.Value == eint2; + public static bool operator !=(EncInt eint1, int eint2) => eint1.Value != eint2; + public static bool operator >(EncInt eint1, int eint2) => eint1.Value > eint2; + public static bool operator <(EncInt eint1, int eint2) => eint1.Value < eint2; public static bool operator ==(EncInt eint1, ushort eint2) => (ushort)eint1.Value == eint2; public static bool operator !=(EncInt eint1, ushort eint2) => (ushort)eint1.Value != eint2; @@ -146,34 +152,34 @@ private EncInt(double value) public static bool operator >(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value > eint2; public static bool operator <(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value < eint2; - public static bool operator ==(EncInt eint1, decimal eint2) => (decimal)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, decimal eint2) => (decimal)eint1.Value != eint2; - public static bool operator >(EncInt eint1, decimal eint2) => (decimal)eint1.Value > eint2; - public static bool operator <(EncInt eint1, decimal eint2) => (decimal)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, decimal eint2) => eint1.Value == eint2; + public static bool operator !=(EncInt eint1, decimal eint2) => eint1.Value != eint2; + public static bool operator >(EncInt eint1, decimal eint2) => eint1.Value > eint2; + public static bool operator <(EncInt eint1, decimal eint2) => eint1.Value < eint2; - public static bool operator ==(EncInt eint1, double eint2) => (double)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, double eint2) => (double)eint1.Value != eint2; - public static bool operator >(EncInt eint1, double eint2) => (double)eint1.Value > eint2; - public static bool operator <(EncInt eint1, double eint2) => (double)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, double eint2) => eint1.Value == eint2; + public static bool operator !=(EncInt eint1, double eint2) => eint1.Value != eint2; + public static bool operator >(EncInt eint1, double eint2) => eint1.Value > eint2; + public static bool operator <(EncInt eint1, double eint2) => eint1.Value < eint2; - public static bool operator ==(EncInt eint1, float eint2) => (float)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, float eint2) => (float)eint1.Value != eint2; - public static bool operator >(EncInt eint1, float eint2) => (float)eint1.Value > eint2; - public static bool operator <(EncInt eint1, float eint2) => (float)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, float eint2) => eint1.Value == eint2; + public static bool operator !=(EncInt eint1, float eint2) => eint1.Value != eint2; + public static bool operator >(EncInt eint1, float eint2) => eint1.Value > eint2; + public static bool operator <(EncInt eint1, float eint2) => eint1.Value < eint2; /// assign public static implicit operator EncInt(int value) => new EncInt(value); public static explicit operator ulong(EncInt eint1) => (ulong)eint1.Value; - public static implicit operator long(EncInt eint1) => (long)eint1.Value; + public static implicit operator long(EncInt eint1) => eint1.Value; public static explicit operator uint(EncInt eint1) => (uint)eint1.Value; - public static implicit operator int(EncInt eint1) => (int)eint1.Value; + public static implicit operator int(EncInt eint1) => eint1.Value; public static explicit operator ushort(EncInt eint1) => (ushort)eint1.Value; public static explicit operator short(EncInt eint1) => (short)eint1.Value; public static explicit operator byte(EncInt eint1) => (byte)eint1.Value; public static explicit operator sbyte(EncInt eint1) => (sbyte)eint1.Value; - public static explicit operator decimal(EncInt eint1) => (decimal)eint1.Value; - public static explicit operator double(EncInt eint1) => eint1.Value; - public static explicit operator float(EncInt eint1) => (float)eint1.Value; + public static implicit operator decimal(EncInt eint1) => eint1.Value; + public static implicit operator double(EncInt eint1) => eint1.Value; + public static implicit operator float(EncInt eint1) => eint1.Value; #endregion } \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs index e1b2450..e5fd407 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs @@ -8,7 +8,7 @@ public struct EncLong /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc - #region Variables And Properties + #region Variables - Properties - Methods - Constructors // The encryption values private readonly decimal encryptionKey1; @@ -18,22 +18,18 @@ public struct EncLong private readonly decimal encryptedValue; // The decrypted value - private decimal Value + private long Value { - get => Math.Round(Decrypt()); + get => (long)Decrypt(); } public long MaxValue { get => Int64.MaxValue; } public long MinValue { get => Int64.MinValue; } - #endregion - - #region Methods & Constructors - private EncLong(decimal value) { - encryptionKey1 = (decimal)random.NextDouble(); - encryptionKey2 = (decimal)random.NextDouble(); + encryptionKey1 = (decimal)(random.NextDouble() * 0.001); + encryptionKey2 = (decimal)(random.NextDouble() * 100); encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); } @@ -44,129 +40,138 @@ private EncLong(decimal value) private static decimal Encrypt(decimal value, decimal k1, decimal k2) => (value + k1) * k2; // Takes an encrypted value and returns it decrypted - private decimal Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + private decimal Decrypt() => ((encryptedValue / encryptionKey2) - encryptionKey1) + 0.5m; // Int64 methods - public int CompareTo(object value) => ((long)Value).CompareTo(value); - public int CompareTo(long value) => ((long)Value).CompareTo(value); - public bool Equals(long obj) => ((long)Value).Equals(obj); - public override bool Equals(object obj) => ((long)Value).Equals(obj); - public override int GetHashCode() => ((long)Value).GetHashCode(); - public TypeCode GetTypeCode() => ((long)Value).GetTypeCode(); - public override string ToString() => ((long)Value).ToString(); - public string ToString(IFormatProvider provider) => ((long)Value).ToString(provider); - public string ToString(string format) => ((long)Value).ToString(format); - public string ToString(string format, IFormatProvider provider) => ((long)Value).ToString(format, provider); + public int CompareTo(object value) => Value.CompareTo(value); + public int CompareTo(long value) => Value.CompareTo(value); + public bool Equals(long obj) => Value.Equals(obj); + public override bool Equals(object obj) => Value.Equals(obj); + public override int GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public override string ToString() => Value.ToString(); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public string ToString(string format) => Value.ToString(format); + public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); #endregion #region Operators Overloading + /// & | ^ + public static EncLong operator &(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value & elong2.Value); + public static EncLong operator |(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value | elong2.Value); + public static EncLong operator ^(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value ^ elong2.Value); + + public static long operator &(EncLong elong1, long elong2) => elong1.Value & elong2; + public static long operator |(EncLong elong1, long elong2) => elong1.Value | elong2; + public static long operator ^(EncLong elong1, long elong2) => elong1.Value ^ elong2; + /// + - * / % - public static EncLong operator +(EncLong elong1, EncLong elong2) => new EncLong(Math.Round(elong1.Decrypt() + elong2.Decrypt())); - public static EncLong operator -(EncLong elong1, EncLong elong2) => new EncLong(Math.Round(elong1.Decrypt() - elong2.Decrypt())); - public static EncLong operator *(EncLong elong1, EncLong elong2) => new EncLong(Math.Round(elong1.Decrypt() * elong2.Decrypt())); - public static EncLong operator /(EncLong elong1, EncLong elong2) => new EncLong(Math.Round(elong1.Decrypt() / elong2.Decrypt())); - public static EncLong operator %(EncLong elong1, EncLong elong2) => new EncLong(Math.Round(elong1.Decrypt() % elong2.Decrypt())); - - public static long operator +(EncLong elong1, long elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, long elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, long elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, long elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, long elong2) => (long)elong1.Value % elong2; - - public static long operator +(EncLong elong1, int elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, int elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, int elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, int elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, int elong2) => (long)elong1.Value % elong2; - - public static long operator +(EncLong elong1, short elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, short elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, short elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, short elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, short elong2) => (long)elong1.Value % elong2; - - public static long operator +(EncLong elong1, ushort elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, ushort elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, ushort elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, ushort elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, ushort elong2) => (long)elong1.Value % elong2; - - public static long operator +(EncLong elong1, uint elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, uint elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, uint elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, uint elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, uint elong2) => (long)elong1.Value % elong2; - - public static long operator +(EncLong elong1, byte elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, byte elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, byte elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, byte elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, byte elong2) => (long)elong1.Value % elong2; - - public static long operator +(EncLong elong1, sbyte elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, sbyte elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, sbyte elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, sbyte elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, sbyte elong2) => (long)elong1.Value % elong2; + public static EncLong operator +(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value + elong2.Value); + public static EncLong operator -(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value - elong2.Value); + public static EncLong operator *(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value * elong2.Value); + public static EncLong operator /(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value / elong2.Value); + public static EncLong operator %(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value % elong2.Value); + + public static long operator +(EncLong elong1, long elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, long elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, long elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, long elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, long elong2) => elong1.Value % elong2; + + public static long operator +(EncLong elong1, int elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, int elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, int elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, int elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, int elong2) => elong1.Value % elong2; + + public static long operator +(EncLong elong1, short elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, short elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, short elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, short elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, short elong2) => elong1.Value % elong2; + + public static long operator +(EncLong elong1, ushort elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, ushort elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, ushort elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, ushort elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, ushort elong2) => elong1.Value % elong2; + + public static long operator +(EncLong elong1, uint elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, uint elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, uint elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, uint elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, uint elong2) => elong1.Value % elong2; + + public static long operator +(EncLong elong1, byte elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, byte elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, byte elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, byte elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, byte elong2) => elong1.Value % elong2; + + public static long operator +(EncLong elong1, sbyte elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, sbyte elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, sbyte elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, sbyte elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, sbyte elong2) => elong1.Value % elong2; /// == != < > /// - public static bool operator ==(EncLong elong1, byte elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, byte elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, byte elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, byte elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, sbyte elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, sbyte elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, sbyte elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, sbyte elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, short elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, short elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, short elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, short elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, ushort elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, ushort elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, ushort elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, ushort elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, uint elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, uint elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, uint elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, uint elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, int elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, int elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, int elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, int elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, long elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, long elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, long elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, long elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, EncLong elong2) => (long)elong1.Value == (long)elong2.Value; - public static bool operator !=(EncLong elong1, EncLong elong2) => (long)elong1.Value != (long)elong2.Value; - public static bool operator <(EncLong elong1, EncLong elong2) => (long)elong1.Value < (long)elong2.Value; - public static bool operator >(EncLong elong1, EncLong elong2) => (long)elong1.Value > (long)elong2.Value; + public static bool operator ==(EncLong elong1, byte elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, byte elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, byte elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, byte elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, sbyte elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, sbyte elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, sbyte elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, sbyte elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, short elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, short elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, short elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, short elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, ushort elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, ushort elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, ushort elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, ushort elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, uint elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, uint elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, uint elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, uint elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, int elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, int elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, int elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, int elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, long elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, long elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, long elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, long elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, EncLong elong2) => elong1.Value == elong2.Value; + public static bool operator !=(EncLong elong1, EncLong elong2) => elong1.Value != elong2.Value; + public static bool operator <(EncLong elong1, EncLong elong2) => elong1.Value < elong2.Value; + public static bool operator >(EncLong elong1, EncLong elong2) => elong1.Value > elong2.Value; /// assign public static implicit operator EncLong(long value) => new EncLong(value); public static explicit operator ulong(EncLong elong1) => (ulong)elong1.Value; - public static implicit operator long(EncLong elong1) => (long)elong1.Value; + public static implicit operator long(EncLong elong1) => elong1.Value; public static explicit operator uint(EncLong elong1) => (uint)elong1.Value; public static explicit operator int(EncLong elong1) => (int)elong1.Value; public static explicit operator ushort(EncLong elong1) => (ushort)elong1.Value; public static explicit operator short(EncLong elong1) => (short)elong1.Value; public static explicit operator byte(EncLong elong1) => (byte)elong1.Value; public static explicit operator sbyte(EncLong elong1) => (sbyte)elong1.Value; - public static explicit operator decimal(EncLong elong1) => elong1.Value; - public static explicit operator double(EncLong elong1) => (double)elong1.Value; - public static explicit operator float(EncLong elong1) => (float)elong1.Value; + public static implicit operator decimal(EncLong elong1) => elong1.Value; + public static implicit operator double(EncLong elong1) => elong1.Value; + public static implicit operator float(EncLong elong1) => elong1.Value; #endregion } \ No newline at end of file From 46361858d5e5f938321ebf236614d117a8ecd608 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Thu, 17 Dec 2020 03:44:44 +0200 Subject: [PATCH 06/53] Bug fix for EncFloat/Double/Decimal A bug that could result in a data loss or an error --- .../Variable-Encryption/Types/EncDecimal.cs | 8 ++++---- .../Variable-Encryption/Types/EncDouble.cs | 8 ++++---- .../Variable-Encryption/Types/EncFloat.cs | 8 ++++---- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs index 26088a0..1e3753b 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs @@ -35,8 +35,8 @@ private decimal Value private EncDecimal(decimal value) { - encryptionKey1 = (decimal)random.NextDouble(); - encryptionKey2 = (decimal)random.NextDouble(); + encryptionKey1 = (decimal)(random.NextDouble() * 0.001); + encryptionKey2 = (decimal)(random.NextDouble() * 100); encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); } @@ -44,10 +44,10 @@ private EncDecimal(decimal value) static private Random random = new Random(); // Takes a given value and returns it encrypted - private static decimal Encrypt(decimal value, decimal k1, decimal k2) => (value + k1) * k2; + private static decimal Encrypt(decimal value, decimal k1, decimal k2) => (value * k1) * k2; // Takes an encrypted value and returns it decrypted - private decimal Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + private decimal Decrypt() => (encryptedValue / encryptionKey2) / encryptionKey1; // Overrides public int CompareTo(Decimal value) => Value.CompareTo(value); diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs index f5db517..784cf35 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs @@ -36,8 +36,8 @@ public double Value private EncDouble(double value) { - encryptionKey1 = random.NextDouble(); - encryptionKey2 = random.NextDouble(); + encryptionKey1 = random.NextDouble() * 0.001; + encryptionKey2 = random.NextDouble() * 100; encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); } @@ -45,10 +45,10 @@ private EncDouble(double value) static private Random random = new Random(); // Takes a given value and returns it encrypted - private static double Encrypt(double value, double k1, double k2) => (value + k1) * k2; + private static double Encrypt(double value, double k1, double k2) => (value * k1) * k2; // Takes an encrypted value and returns it decrypted - private double Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + private double Decrypt() => (encryptedValue / encryptionKey2) / encryptionKey1; // Overrides public int CompareTo(object value) => Value.CompareTo(value); diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs index 67f5a75..f11acb8 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs @@ -36,8 +36,8 @@ private float Value private EncFloat(float value) { - encryptionKey1 = random.NextDouble(); - encryptionKey2 = random.NextDouble(); + encryptionKey1 = random.NextDouble() * 0.001; + encryptionKey2 = random.NextDouble() * 100; encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); } @@ -45,10 +45,10 @@ private EncFloat(float value) static private Random random = new Random(); // Takes a given value and returns it encrypted - private static double Encrypt(double value, double k1, double k2) => (value + k1) * k2; + private static double Encrypt(double value, double k1, double k2) => (value * k1) * k2; // Takes an encrypted value and returns it decrypted - private double Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + private double Decrypt() => (encryptedValue / encryptionKey2) / encryptionKey1; // Single methods public int CompareTo(Single value) => Value.CompareTo(value); From c0d14a5ec477bd283afdde43aa1521cb4baefe54 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Thu, 17 Dec 2020 03:45:54 +0200 Subject: [PATCH 07/53] Updated benchmark - Added old types to the banchmark - Updated the executable's .dll file --- .../Benchmark/BenchmarksManager.cs | 19 +- .../Benchmark/TestLibrary.cs | 26 +++ .../OldTypes/EncInt_0_9_0.cs | 179 +++++++++++++++ .../OldTypes/EncString_0_9_0.cs | 203 ++++++++++++++++++ Benchmark/VariableEncryption.dll | Bin 91648 -> 96256 bytes 5 files changed, 423 insertions(+), 4 deletions(-) create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_9_0.cs create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_9_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs index 78f7342..c671c64 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs @@ -33,25 +33,36 @@ public static class BenchmarksManager new TypeInBenchmark("EncDouble (0.7.0)", WL_EncDouble_0_7_0), // 18 new TypeInBenchmark("EncDouble (0.8.0)", WL_EncDouble_0_8_0), new TypeInBenchmark("EncString (0.8.0)", WL_EncString_0_8_0), // 20 + new TypeInBenchmark("EncInt (0.9.0)", WL_EncInt_0_9_0), + new TypeInBenchmark("EncString (0.9.0)", WL_EncString_0_9_0), // 22 }; static public BenchmarkData[] comparisons = { + // EncInt new BenchmarkData(benchmarkTypes[0], benchmarkTypes[1]), new BenchmarkData(benchmarkTypes[0], benchmarkTypes[14]), new BenchmarkData(benchmarkTypes[0], benchmarkTypes[15]), new BenchmarkData(benchmarkTypes[0], benchmarkTypes[16]), - new BenchmarkData(benchmarkTypes[2], benchmarkTypes[3]), - new BenchmarkData(benchmarkTypes[4], benchmarkTypes[5]), + new BenchmarkData(benchmarkTypes[0], benchmarkTypes[21]), + + new BenchmarkData(benchmarkTypes[2], benchmarkTypes[3]), // long + new BenchmarkData(benchmarkTypes[4], benchmarkTypes[5]), // float + + // EncDouble new BenchmarkData(benchmarkTypes[6], benchmarkTypes[7]), new BenchmarkData(benchmarkTypes[6], benchmarkTypes[17]), new BenchmarkData(benchmarkTypes[6], benchmarkTypes[18]), new BenchmarkData(benchmarkTypes[6], benchmarkTypes[19]), - new BenchmarkData(benchmarkTypes[8], benchmarkTypes[9]), + + new BenchmarkData(benchmarkTypes[8], benchmarkTypes[9]), // decimal + + // EncString new BenchmarkData(benchmarkTypes[10], benchmarkTypes[11]), new BenchmarkData(benchmarkTypes[10], benchmarkTypes[12]), new BenchmarkData(benchmarkTypes[10], benchmarkTypes[13]), new BenchmarkData(benchmarkTypes[10], benchmarkTypes[20]), + new BenchmarkData(benchmarkTypes[10], benchmarkTypes[22]), }; static BenchmarkPreset[] benchmarkPresetsFastest = @@ -160,7 +171,7 @@ public static void RunTests(int changesAmount, int testsAmount, Action whil timeSpans.Add(testsStopWatch.Elapsed); } - WriteLine(" "); + WriteLine(); TimeSpan average = GetAverage(timeSpans); DisplayAverage(average); currentBenchmarkResults.SetAverageTimeSpan(average); diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs index ef02381..cc2ae45 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs @@ -65,6 +65,15 @@ public static void WL_EncInt_0_8_0(int amount) } } + public static void WL_EncInt_0_9_0(int amount) + { + EncInt_0_9_0 number1 = 0; + while (number1 < amount) + { + number1++; + } + } + public static void WL_Long(int amount) { long number1 = 0; @@ -267,5 +276,22 @@ public static void WL_EncString_0_8_0(int amount) } } + public static void WL_EncString_0_9_0(int amount) + { + EncString_0_9_0 stringVar = RandomString(); + int currentPos = 0; + int timesIncremented = 0; + while (timesIncremented < amount) + { + timesIncremented++; + stringVar = StringReplaceAt(stringVar, currentPos, RandomCharNormal()); + currentPos++; + if (currentPos >= stringVar.Length) + { + currentPos = 0; + } + } + } + #endregion } \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_9_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_9_0.cs new file mode 100644 index 0000000..b5a17d6 --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_9_0.cs @@ -0,0 +1,179 @@ +using System; + +public struct EncInt_0_9_0 +{ + /// A struct for storing a 32-bit integer while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an int. + /// + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + + #region Variables And Properties + + // The encryption values + private readonly double encryptionKey1; + private readonly double encryptionKey2; + + // The encrypted value stored in memory + private readonly double encryptedValue; + + // The decrypted value + private double Value + { + get => Math.Round(Decrypt()); + } + + public int MaxValue { get => Int32.MaxValue; } + public int MinValue { get => Int32.MinValue; } + + #endregion + + #region Methods + + private EncInt_0_9_0(double value) + { + encryptionKey1 = random.NextDouble(); + encryptionKey2 = random.NextDouble(); + encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + } + + // Encryption Key Generator + static private Random random = new Random(); + + // Takes a given value and returns it encrypted + private static double Encrypt(double value, double k1, double k2) => (value + k1) * k2; + + // Takes an encrypted value and returns it decrypted + private double Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + + // Int32 methods + public Int32 CompareTo(object value) => ((int)Value).CompareTo(value); + public Int32 CompareTo(Int32 value) => ((int)Value).CompareTo(value); + public bool Equals(Int32 obj) => ((int)Value).Equals(obj); + public override bool Equals(object obj) => ((int)Value).Equals(obj); + public override Int32 GetHashCode() => ((int)Value).GetHashCode(); + public TypeCode GetTypeCode() => ((int)Value).GetTypeCode(); + public override string ToString() => ((int)Value).ToString(); + public string ToString(IFormatProvider provider) => ((int)Value).ToString(provider); + public string ToString(string format) => ((int)Value).ToString(format); + public string ToString(string format, IFormatProvider provider) => ((int)Value).ToString(format, provider); + + #endregion + + #region Operators Overloading + + /// + - * / % + public static EncInt_0_9_0 operator +(EncInt_0_9_0 eint1, EncInt_0_9_0 eint2) => new EncInt_0_9_0((int)Math.Round(eint1.Decrypt() + eint2.Decrypt())); + public static EncInt_0_9_0 operator -(EncInt_0_9_0 eint1, EncInt_0_9_0 eint2) => new EncInt_0_9_0((int)Math.Round(eint1.Decrypt() - eint2.Decrypt())); + public static EncInt_0_9_0 operator *(EncInt_0_9_0 eint1, EncInt_0_9_0 eint2) => new EncInt_0_9_0((int)Math.Round(eint1.Decrypt() * eint2.Decrypt())); + public static EncInt_0_9_0 operator /(EncInt_0_9_0 eint1, EncInt_0_9_0 eint2) => new EncInt_0_9_0((int)Math.Round(eint1.Decrypt() / eint2.Decrypt())); + public static EncInt_0_9_0 operator %(EncInt_0_9_0 eint1, EncInt_0_9_0 eint2) => new EncInt_0_9_0((int)Math.Round(eint1.Decrypt() % eint2.Decrypt())); + + public static int operator +(EncInt_0_9_0 eint1, int eint2) => (int)eint1.Value + eint2; + public static int operator -(EncInt_0_9_0 eint1, int eint2) => (int)eint1.Value - eint2; + public static int operator *(EncInt_0_9_0 eint1, int eint2) => (int)eint1.Value * eint2; + public static int operator /(EncInt_0_9_0 eint1, int eint2) => (int)eint1.Value / eint2; + public static int operator %(EncInt_0_9_0 eint1, int eint2) => (int)eint1.Value % eint2; + + public static int operator +(EncInt_0_9_0 eint1, ushort eint2) => (int)eint1.Value + eint2; + public static int operator -(EncInt_0_9_0 eint1, ushort eint2) => (int)eint1.Value - eint2; + public static int operator *(EncInt_0_9_0 eint1, ushort eint2) => (int)eint1.Value * eint2; + public static int operator /(EncInt_0_9_0 eint1, ushort eint2) => (int)eint1.Value / eint2; + public static int operator %(EncInt_0_9_0 eint1, ushort eint2) => (int)eint1.Value % eint2; + + public static int operator +(EncInt_0_9_0 eint1, short eint2) => (int)eint1.Value + eint2; + public static int operator -(EncInt_0_9_0 eint1, short eint2) => (int)eint1.Value - eint2; + public static int operator *(EncInt_0_9_0 eint1, short eint2) => (int)eint1.Value * eint2; + public static int operator /(EncInt_0_9_0 eint1, short eint2) => (int)eint1.Value / eint2; + public static int operator %(EncInt_0_9_0 eint1, short eint2) => (int)eint1.Value % eint2; + + public static int operator +(EncInt_0_9_0 eint1, byte eint2) => (int)eint1.Value + eint2; + public static int operator -(EncInt_0_9_0 eint1, byte eint2) => (int)eint1.Value - eint2; + public static int operator *(EncInt_0_9_0 eint1, byte eint2) => (int)eint1.Value * eint2; + public static int operator /(EncInt_0_9_0 eint1, byte eint2) => (int)eint1.Value / eint2; + public static int operator %(EncInt_0_9_0 eint1, byte eint2) => (int)eint1.Value % eint2; + + public static int operator +(EncInt_0_9_0 eint1, sbyte eint2) => (int)eint1.Value + eint2; + public static int operator -(EncInt_0_9_0 eint1, sbyte eint2) => (int)eint1.Value - eint2; + public static int operator *(EncInt_0_9_0 eint1, sbyte eint2) => (int)eint1.Value * eint2; + public static int operator /(EncInt_0_9_0 eint1, sbyte eint2) => (int)eint1.Value / eint2; + public static int operator %(EncInt_0_9_0 eint1, sbyte eint2) => (int)eint1.Value % eint2; + + /// == != < > + + public static bool operator ==(EncInt_0_9_0 eint1, EncInt_0_9_0 eint2) => eint1.Value == eint2.Value; + public static bool operator !=(EncInt_0_9_0 eint1, EncInt_0_9_0 eint2) => eint1.Value != eint2.Value; + public static bool operator <(EncInt_0_9_0 eint1, EncInt_0_9_0 eint2) => eint1.Value < eint2.Value; + public static bool operator >(EncInt_0_9_0 eint1, EncInt_0_9_0 eint2) => eint1.Value > eint2.Value; + + public static bool operator ==(EncInt_0_9_0 eint1, ulong eint2) => (ulong)eint1.Value == eint2; + public static bool operator !=(EncInt_0_9_0 eint1, ulong eint2) => (ulong)eint1.Value != eint2; + public static bool operator >(EncInt_0_9_0 eint1, ulong eint2) => (ulong)eint1.Value > eint2; + public static bool operator <(EncInt_0_9_0 eint1, ulong eint2) => (ulong)eint1.Value < eint2; + + public static bool operator ==(EncInt_0_9_0 eint1, long eint2) => (long)eint1.Value == eint2; + public static bool operator !=(EncInt_0_9_0 eint1, long eint2) => (long)eint1.Value != eint2; + public static bool operator >(EncInt_0_9_0 eint1, long eint2) => (long)eint1.Value > eint2; + public static bool operator <(EncInt_0_9_0 eint1, long eint2) => (long)eint1.Value < eint2; + + public static bool operator ==(EncInt_0_9_0 eint1, uint eint2) => (uint)eint1.Value == eint2; + public static bool operator !=(EncInt_0_9_0 eint1, uint eint2) => (uint)eint1.Value != eint2; + public static bool operator >(EncInt_0_9_0 eint1, uint eint2) => (uint)eint1.Value > eint2; + public static bool operator <(EncInt_0_9_0 eint1, uint eint2) => (uint)eint1.Value < eint2; + + public static bool operator ==(EncInt_0_9_0 eint1, int eint2) => (int)eint1.Value == eint2; + public static bool operator !=(EncInt_0_9_0 eint1, int eint2) => (int)eint1.Value != eint2; + public static bool operator >(EncInt_0_9_0 eint1, int eint2) => (int)eint1.Value > eint2; + public static bool operator <(EncInt_0_9_0 eint1, int eint2) => (int)eint1.Value < eint2; + + public static bool operator ==(EncInt_0_9_0 eint1, ushort eint2) => (ushort)eint1.Value == eint2; + public static bool operator !=(EncInt_0_9_0 eint1, ushort eint2) => (ushort)eint1.Value != eint2; + public static bool operator >(EncInt_0_9_0 eint1, ushort eint2) => (ushort)eint1.Value > eint2; + public static bool operator <(EncInt_0_9_0 eint1, ushort eint2) => (ushort)eint1.Value < eint2; + + public static bool operator ==(EncInt_0_9_0 eint1, short eint2) => (short)eint1.Value == eint2; + public static bool operator !=(EncInt_0_9_0 eint1, short eint2) => (short)eint1.Value != eint2; + public static bool operator >(EncInt_0_9_0 eint1, short eint2) => (short)eint1.Value > eint2; + public static bool operator <(EncInt_0_9_0 eint1, short eint2) => (short)eint1.Value < eint2; + + public static bool operator ==(EncInt_0_9_0 eint1, byte eint2) => (byte)eint1.Value == eint2; + public static bool operator !=(EncInt_0_9_0 eint1, byte eint2) => (byte)eint1.Value != eint2; + public static bool operator >(EncInt_0_9_0 eint1, byte eint2) => (byte)eint1.Value > eint2; + public static bool operator <(EncInt_0_9_0 eint1, byte eint2) => (byte)eint1.Value < eint2; + + public static bool operator ==(EncInt_0_9_0 eint1, sbyte eint2) => (sbyte)eint1.Value == eint2; + public static bool operator !=(EncInt_0_9_0 eint1, sbyte eint2) => (sbyte)eint1.Value != eint2; + public static bool operator >(EncInt_0_9_0 eint1, sbyte eint2) => (sbyte)eint1.Value > eint2; + public static bool operator <(EncInt_0_9_0 eint1, sbyte eint2) => (sbyte)eint1.Value < eint2; + + public static bool operator ==(EncInt_0_9_0 eint1, decimal eint2) => (decimal)eint1.Value == eint2; + public static bool operator !=(EncInt_0_9_0 eint1, decimal eint2) => (decimal)eint1.Value != eint2; + public static bool operator >(EncInt_0_9_0 eint1, decimal eint2) => (decimal)eint1.Value > eint2; + public static bool operator <(EncInt_0_9_0 eint1, decimal eint2) => (decimal)eint1.Value < eint2; + + public static bool operator ==(EncInt_0_9_0 eint1, double eint2) => (double)eint1.Value == eint2; + public static bool operator !=(EncInt_0_9_0 eint1, double eint2) => (double)eint1.Value != eint2; + public static bool operator >(EncInt_0_9_0 eint1, double eint2) => (double)eint1.Value > eint2; + public static bool operator <(EncInt_0_9_0 eint1, double eint2) => (double)eint1.Value < eint2; + + public static bool operator ==(EncInt_0_9_0 eint1, float eint2) => (float)eint1.Value == eint2; + public static bool operator !=(EncInt_0_9_0 eint1, float eint2) => (float)eint1.Value != eint2; + public static bool operator >(EncInt_0_9_0 eint1, float eint2) => (float)eint1.Value > eint2; + public static bool operator <(EncInt_0_9_0 eint1, float eint2) => (float)eint1.Value < eint2; + + /// assign + public static implicit operator EncInt_0_9_0(int value) => new EncInt_0_9_0(value); + public static explicit operator ulong(EncInt_0_9_0 eint1) => (ulong)eint1.Value; + public static implicit operator long(EncInt_0_9_0 eint1) => (long)eint1.Value; + public static explicit operator uint(EncInt_0_9_0 eint1) => (uint)eint1.Value; + public static implicit operator int(EncInt_0_9_0 eint1) => (int)eint1.Value; + public static explicit operator ushort(EncInt_0_9_0 eint1) => (ushort)eint1.Value; + public static explicit operator short(EncInt_0_9_0 eint1) => (short)eint1.Value; + public static explicit operator byte(EncInt_0_9_0 eint1) => (byte)eint1.Value; + public static explicit operator sbyte(EncInt_0_9_0 eint1) => (sbyte)eint1.Value; + public static explicit operator decimal(EncInt_0_9_0 eint1) => (decimal)eint1.Value; + public static explicit operator double(EncInt_0_9_0 eint1) => eint1.Value; + public static explicit operator float(EncInt_0_9_0 eint1) => (float)eint1.Value; + + #endregion +} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_9_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_9_0.cs new file mode 100644 index 0000000..5683809 --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_9_0.cs @@ -0,0 +1,203 @@ +using System; +using System.Globalization; +using System.Text; + +public class EncString_0_9_0 +{ + /// A class for storing a string while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a wierd string that is affected by a very long random key. { encryptionKey } + /// Every time the value of the string changes, the encryption key changes too. And it works exactly as an string. + /// + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + + #region Variables And Properties + + private readonly string _encryptionKey; + private readonly string _encryptedValue; + + /// + /// The decrypted value of the stored string. + /// + private string Value + { + get => EncryptorDecryptor(_encryptedValue, _encryptionKey); + } + + public int Length + { + get => Value.Length; + } + + public static string Empty + { + get => string.Empty; + } + + public char this[int index] + { + get => Value[index]; + } + + #endregion + + #region Methods + + public bool IsEqual(EncString_0_9_0 encString) => encString.Value == this.Value; + public bool IsNull() => this.Value == null; + public object Clone() => Value.Clone(); + public override bool Equals(object obj) => Value.Equals(obj); + public override int GetHashCode() => Value.GetHashCode(); + public bool Contains(string value) => Value.Contains(value); + public int CompareTo(object value) => Value.CompareTo(value); + public int CompareTo(string strB) => Value.CompareTo(strB); + public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) => Value.CopyTo(sourceIndex, destination, destinationIndex, count); + public bool EndsWith(string value) => Value.EndsWith(value); + public bool EndsWith(string value, StringComparison comparisonType) => Value.EndsWith(value, comparisonType); + public bool EndsWith(string value, bool ignoreCase, CultureInfo culture) => Value.EndsWith(value, ignoreCase, culture); + public CharEnumerator GetEnumerator() => Value.GetEnumerator(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public int IndexOf(string value, int startIndex, StringComparison comparisonType) => Value.IndexOf(value, startIndex, comparisonType); + public int IndexOf(string value, StringComparison comparisonType) => Value.IndexOf(value, comparisonType); + public int IndexOf(string value, int startIndex, int count) => Value.IndexOf(value, startIndex, count); + public int IndexOf(string value) => Value.IndexOf(value); + public int IndexOf(char value, int startIndex, int count) => Value.IndexOf(value, startIndex, count); + public int IndexOf(char value, int startIndex) => Value.IndexOf(value, startIndex); + public int IndexOf(char value) => Value.IndexOf(value); + public int IndexOf(string value, int startIndex, int count, StringComparison comparisonType) => Value.IndexOf(value, startIndex, count, comparisonType); + public int IndexOf(string value, int startIndex) => Value.IndexOf(value, startIndex); + public int IndexOfAny(char[] anyOf) => Value.IndexOfAny(anyOf); + public int IndexOfAny(char[] anyOf, int startIndex, int count) => Value.IndexOfAny(anyOf, startIndex, count); + public int IndexOfAny(char[] anyOf, int startIndex) => Value.IndexOfAny(anyOf, startIndex); + public string Insert(int startIndex, string value) => Value.Insert(startIndex, value); + public bool IsNormalized() => Value.IsNormalized(); + public bool IsNormalized(NormalizationForm normalizationForm) => Value.IsNormalized(normalizationForm); + public int LastIndexOf(string value, int startIndex, StringComparison comparisonType) => Value.LastIndexOf(value, startIndex, comparisonType); + public int LastIndexOf(string value, int startIndex, int count, StringComparison comparisonType) => Value.LastIndexOf(value, startIndex, count, comparisonType); + public int LastIndexOf(string value, int startIndex, int count) => Value.LastIndexOf(value, startIndex, count); + public int LastIndexOf(string value, StringComparison comparisonType) => Value.LastIndexOf(value, comparisonType); + public int LastIndexOf(string value) => Value.LastIndexOf(value); + public int LastIndexOf(char value, int startIndex, int count) => Value.LastIndexOf(value, startIndex, count); + public int LastIndexOf(char value, int startIndex) => Value.LastIndexOf(value, startIndex); + public int LastIndexOf(string value, int startIndex) => Value.LastIndexOf(value, startIndex); + public int LastIndexOf(char value) => Value.LastIndexOf(value); + public int LastIndexOfAny(char[] anyOf) => Value.LastIndexOfAny(anyOf); + public int LastIndexOfAny(char[] anyOf, int startIndex) => Value.LastIndexOfAny(anyOf, startIndex); + public int LastIndexOfAny(char[] anyOf, int startIndex, int count) => Value.LastIndexOfAny(anyOf, startIndex, count); + public string Normalize() => Value.Normalize(); + public string Normalize(NormalizationForm normalizationForm) => Value.Normalize(normalizationForm); + public string PadLeft(int totalWidth) => Value.PadLeft(totalWidth); + public string PadLeft(int totalWidth, char paddingChar) => Value.PadLeft(totalWidth, paddingChar); + public string PadRight(int totalWidth) => Value.PadRight(totalWidth); + public string PadRight(int totalWidth, char paddingChar) => Value.PadRight(totalWidth, paddingChar); + public string Remove(int startIndex) => Value.Remove(startIndex); + public string Remove(int startIndex, int count) => Value.Remove(startIndex, count); + public string Replace(string oldValue, string newValue) => Value.Replace(oldValue, newValue); + public string Replace(char oldChar, char newChar) => Value.Replace(oldChar, newChar); + public string[] Split(string[] separator, int count, StringSplitOptions options) => Value.Split(separator, count, options); + public string[] Split(params char[] separator) => Value.Split(separator); + public string[] Split(char[] separator, int count) => Value.Split(separator, count); + public string[] Split(char[] separator, int count, StringSplitOptions options) => Value.Split(separator, count, options); + public string[] Split(char[] separator, StringSplitOptions options) => Value.Split(separator, options); + public string[] Split(string[] separator, StringSplitOptions options) => Value.Split(separator, options); + public bool StartsWith(string value) => Value.StartsWith(value); + public bool StartsWith(string value, bool ignoreCase, CultureInfo culture) => Value.StartsWith(value, ignoreCase, culture); + public bool StartsWith(string value, StringComparison comparisonType) => Value.StartsWith(value, comparisonType); + public string Substring(int startIndex) => Value.Substring(startIndex); + public string Substring(int startIndex, int length) => Value.Substring(startIndex, length); + public char[] ToCharArray(int startIndex, int length) => Value.ToCharArray(startIndex, length); + public char[] ToCharArray() => Value.ToCharArray(); + public string ToLower() => Value.ToLower(); + public string ToLower(CultureInfo culture) => Value.ToLower(culture); + public string ToLowerInvariant() => Value.ToLowerInvariant(); + public override string ToString() => Value.ToString(); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public string ToUpper() => Value.ToUpper(); + public string ToUpper(CultureInfo culture) => Value.ToUpper(culture); + public string ToUpperInvariant() => Value.ToUpperInvariant(); + public string Trim() => Value.Trim(); + public string Trim(params char[] trimChars) => Value.Trim(trimChars); + public string TrimEnd(params char[] trimChars) => Value.TrimEnd(trimChars); + public string TrimStart(params char[] trimChars) => Value.TrimStart(trimChars); + + #endregion + + #region Constructors + + public EncString_0_9_0(string value) + { + _encryptionKey = RandomString(); + _encryptedValue = EncryptorDecryptor(value, _encryptionKey); + } + + public EncString_0_9_0(char[] value) + : this(new string(value)) { } + + public EncString_0_9_0(char c, int count) + : this(new string(c, count)) { } + + public EncString_0_9_0(char[] value, int startIndex, int length) + : this(new string(value, startIndex, length)) { } + + + #endregion + + #region Encryption Decryption + + static Random random = new Random(); + + static int RandomLength() => random.Next(10, 150); + + static char RandomChar(int min = char.MinValue, int max = (char.MaxValue - 1)) + { + return (char)(random.Next(min, max)); + } + + static string RandomString() + { + char[] chars = new char[RandomLength()]; + for (int i = 0; i < chars.Length; i++) + { + chars[i] = RandomChar(); + } + return new string(chars); + } + + private static string EncryptorDecryptor(string data, string key) + { + if (data == null) + { + return null; + } + else + { + int dataLen = data.Length; + int keyLen = key.Length; + char[] output = new char[dataLen]; + + for (int i = 0; i < dataLen; ++i) + { + output[i] = (char)(data[i] ^ key[i % keyLen]); + } + + return new string(output); + } + } + + #endregion + + #region Operators Overloading + + /// + + public static EncString_0_9_0 operator +(EncString_0_9_0 enc, string n) => new EncString_0_9_0(enc.Value + n); + public static string operator +(string n, EncString_0_9_0 enc) => enc.Value + n; + + /// == != < > + public static bool operator ==(EncString_0_9_0 es1, string es2) => es1.Value == es2; + public static bool operator !=(EncString_0_9_0 es1, string es2) => es1.Value != es2; + + /// assign + public static implicit operator EncString_0_9_0(string value) => new EncString_0_9_0(value); + public static implicit operator string(EncString_0_9_0 encString) => encString.Value; + + #endregion +} \ No newline at end of file diff --git a/Benchmark/VariableEncryption.dll b/Benchmark/VariableEncryption.dll index d003cb9dfe9b88cdc70bc60bc48e87010b5728df..9d171ea7ffebc2cbb5d5da8b67585f1197056fe7 100644 GIT binary patch literal 96256 zcmdp<349bq_V}x>>YnbIOp<{>Ku97WV-k=<1OX)=qDVj#5kdqx4#8|DXM_>r8#$QB_@CU9Y;j zdNOdtWz1lVnegB5zccm_eB-|g@pCC$x`5+}4!!;Nuyq)C_jUxxH8WrR`*g zGEeKk*mR9CM@maqK)M*x8{ivjhiP5b8&abF_|0~L9_0AXV51i?mMi|B`X-bn?49Kr zI~miE?-q-M!LKJZ76!g$nZ`~F%KuTiSXEtEI>09eeA=Hg;oNh8J0zgKpcBVR_4ds` zJi2|dHaQLiqHa(}#sOx)ci>+IG)Vj8glRQkh;?O9XVC_;{$ST9;3kq`Y*+Y)b<>%} z_HBl;{>m6iyU5Z|{ZIefuGfL9SY;m@x>1k5x>=8|rKjtL$jcBp#lZr^ zrAO(8Sx^uMZ%K_BrD!A5jT$J0%R-DA=v!PCWXggpQBWxyZLEXEPKR%(P97^8MC2~SO?j+pt5;P zud~6-En~d&FsNre(jRT0#sM3o(ow4Mq!YA{kf-v8HpKixX}(Blz9;}+XdltGHE_PT zQHO}t#@0MZuY;p7^}0M1!iS3)z&CH_=ylNZ%rdUmdGPJa%MTz&d&~swG0UKRnjG3l zPhB^3#zh;~V>uvDjb4ux00H)xdgxA=#%@y&wZ}A`g?czBvlR1$ro}M>+XX8yCm&Bw z3_e_5?qU0*l$C`ri8Vq8^y?0O&tT>u+B*sP-hgbfb#*@jMHTJ@>Y<7%fz5WQ(Y$FFraca z2VHBL;!(;Z9I6Y)Q`0OZYL3Zx3p9uP3~2`k>Bg&2##4eCFmhq&Z8ALU82imgsC(k~ z-+vEOn#Zfb#k1ohMB&(^b`2Z?w898D*=AikkkDle#ez7=;=?gffQ{ugsfrhg+6Wo+ zCC;vZ3m6(KkG1f}iHD&9a9k+V@VjXe&JcVTCf^s|&63CH$jy`2iSI*_5CCUvbb0&~ zET^fTivd#XE2g-nWC}ZZycjBg*;gq8?Bk+Qr4@F6Y2{_jU=)-SE-H3X%9;|$v#J)x zIX9vdSXe+2lbx>)FCyW20bV3=IJ+*k36HmiRLqi@ri`$6XBu(URIA_^Ldo^;8E*sb zsT#=?marW1($qntL!O!GfmM|rSX|JfsW|!A`m(6||5#L>6+aBhUJe!T%V{R8p_~kJ zEGLiu!Mr&Ya!7I)WG^aG180uQ6m)LB97>?fW40~NbbJ^nSY8?>JDUFWm0YTl@=9+c zMu2!*Y-T6liN_&PRJ>n{h4Mn>Q8ovPFynC9z(riOaa@L?MY6M0^vO`PO!k(F6EhS=q2w^Bfq^XT2#eh0M5#F`Q{yFJ zYJsiNKT{J2GetkB=3-#%1lj8a+}mZ@JRQGCclxI9+{flWQ2AiRBDb%*UW=JXBOqIfI$zs&m5$Jb>geZ zx>^XS*mr``q8wk`G))}!#f53&TwmNQP2AWQHy7fjvcy7PdWeuVlhWqCw1to!BBd>S zY0IFrD9;xch0^5tO75n~V@mD`c}tmlQAo+dLSE#O!c&S!x+1I;Iq8asQbf}gjYu&M z<^*Q56)@9*Gf>p1c}^0!a#s+~N(3HNtri!h<;# zUvK+{m{ZEI4dt{1qIDpriat?4Cy1fJoKhN5r;3Q-`%zATT4J5%Eo|xM1jA)2r+9Hj zPV<`aR8AWp@CA<-b7G-m{G4Da5zHx7hNu(k63)n}7{*f3TJJgr@`$bHr(geq_qSLOTy>_nYl=g#g-l`M z;mNw@hT%JA=E1F-*$8j(Vm90g;4PrIrx*<1A#qO;c060O2Mn&zhS0a+zp{1^h#=JS zS_tT_TXrZQl;vX#5GF1@$^s%~ECh2?jlqDA^I^DONy{4s3kIEqm9?6KW633x-Le*Q z@HAp7CJsg1`XQPHSY?qT)|ayzz|j+Vy2*Fp(0J;o<&8msS9UhDVG6F=QcQ56nOjBJ z3`a~+QB&dcX;Q@6dBoVpm=fiYf^ zX~!Y^2Q(^Nuig7&qx$#caF>C{0%yA|6Pek6I1GpH*CU~F-ErkPqTVJ?QM;F*rD7Ib z3KryPFkG&J!7Go&+e1a*cIXKB^6c__mRx}?e=?p#*6mai`>f{9v=(EgE4llqhWLh zDk?6h=_uN)wiABw0=Tft;c)Wob@4G^5OeaJ@BwcfpUE&Xa|cO2ha7ZpfxnYfpTpU4IC598V;Uo z@1QlD)&u1_HE0L3lY{5FCTIjGD=jn8Hgfc@L)WLQo6L(L5Z%n`6m-}CT-68WXA7eikQtOXG^+480DGJLNzECHwV){TeRAA4*FGrH7^#BXO*UTRgZB#aIuwo*3O2*Y}&A z-R?UP3;vNF`UZo=5Qr7=n=QDC%W~m*z70}MhD!lt7rz)7a@-}3L1*X_lRgh8ae4s8^PE+0YIRsMRBLwL4%O8Cp!lBP1<+D`!2m$&`0?sH0CQs9UdJe#m<^{Y?6mt_mI2|4LBICx z<458N0jDP96#w0XGKDng{Z}|GqK&3Fz27;258c#R^TZ*!RUTqCbprzW+iv&_DWvFfKIN{b4lo{Y~sondQHX{z8-8 zAJ#X0|4Xv@p9aFX&}8~^Rt5DhPWi*7?-qY~=I!f?Z~LNZQ1OzdryWsHbVzM?9O!$% z2iC1M;|Dbf7SbTk4QCJ~7zAU#p8u$v_~CRS4nJ^VpBr#k!Y)|i8`zf&b{v!kaUIH= zC{Ia2xU5Vpy>mN$7B(o%7`W(#HW$;{{U!`GFxxU&fybBwJrieB?Ou`jL9k-bpDDjM zJletY1etb`nZ_>wNg!uwffa-7i$QmQ?4J_-&|sK9G>V^pV>q_-{0l%5%wJeg{;(MT z&*Tr$)z81%k-xB@{15r(@`vls&mWevGwQ!OBY$B*`FA~7{=sL6Fy+JNfH1?9 z@x)@Cpxt1el$W}(z6-*VPB-68l22feg6aBDINK~O2F@~)-=JwtPw3al=J^mVkHKy( zX7b|N#)%t@dvJdW&w}CETM_h(vMAGG0xjl6^0q<8IWi1lyWs&ZOBP{1u*mGfgDV_2 zVQiphc`}cfG?5jQhIsF%8*x~&rkgZ*&FBoySDJ70jLGdO;+Vt?m6cvXPrpRj$u_DQ z^6`?a5!m3(t}HgWB4v}3`enmi4nC%b^9iF9T=wEiK3#&_y$Xc*_m*_;9y=$i<%;jLC7P+%61v>nMb{_y|HV<8K!3c8Cz-N*f5_KDXR%9`0rf zA+A1x5bo5Lzjg>R_r5Bv3)m* zrq}d`^W@ovd5tYPP#6}tg#BV&^e;nv9^uOGCd11dDQ_|yItO065bzibH8AJF4pNL4 zzHotc1Gt@sC-KBCJYvOxUW^2=r1CaQ>S87=9hjxv_41Hzs9CJc7y1{2>kH~CRuN!i zF(Lmh5KLM!-KjYVsvREyA2J?UIO;T&PmN^-;hbS)daH@rtD%c{_s2XtL7vUi@`UbZ zF>uV5;oDFUgO$JZy&v&PsEXM8(S8n;VAc!-7Htl5U-|DVG;Kt`oMeh4I*(hXp{H8s2v^ zm?uJ+P_nFxC=iBF7()|KU_FEcxsM{>x7GDJ6vn56T3E~T05XgpFb-(@8|OfGh8+@< zF$buq>8GJENbB(_pkTJkMGunxFxOP1LFejdxG+2Vr|Qt8k_JN_IaQ=SmT$tT}qut7zgDz zE{$Nx6i&(MF#e(~jLG;lJU$IRGo@8or6aORtFuZ+N@*#TW(+S?$*NRxL@HUGN{%dT z@4M~SO1r1ha8U$QdLV6<_Der5usk(Wg6^4Se{|GKTk5j%hf)T9N5o!-@fteYN@%ot zI3G9_5#vR$zo9&SIar7WFKq?mwfI+B+6tB_;omoNQ_0^UDb+uwl6wNlxne$o{T0^O zWPgpy{(2c!0y-h~SCNJeB>L+`piup_{T%S4D>qx;#SBE>Mel?3T~v#{iw=RltE=l$ zk1xT4&SwTLyWu#IRd?z^bVClJJ5A~|T#FUsfGQ7Xc&;3~{-}dF(gAgNiOIQIZf2ea zt_L3Q7=}xo0VgD*E{2JFe_U}zVROKBhF`4x{4a$PrZ} z<%lYhazqtLIiiZ>|LpwYn2Fg?SEivgP2vx&L7^O4gA%>;D8Kfzra?9^h4p*wehsq- zs?&|lR4+r%V|`BmbW~k_+I~FJM6#~+#tkMx#rPW!bBc&7v8q8PC6$s>9fk4g`2;^LWK*kaQG*^&mIaiQrIaiQr zIaiQrIad&Af1*P0A1NG%6j>2DSCHv{uHyfVzBpG9$0+9tA}QwzA}QwzA}QwzBKbc% zzc^RGY^W>4uzqT$#Gfk!&E#AmD3Re`)JV-06!~)nUyyDrV}#K8a|Iv#xdO4AD-g)J zf`I>6iRxPX*DCs7;Wmg)eCAvMTbN{Ot`Lx^xk5mu<_hBM&|HDicuLj93A4Xc`rqyc zEp<6k;#@)1Ld+GAL~O@|oGV~T&J{2v=L(pTa|KMvxdNu-Tme&Zu7D{ySHP5-D_{tw zxx%#|uRjJ^-n%ym%oR`^zYYxIqhKy278_tK!eFqfE&m0Ad=IbBxR~0$nfaBa>(-*7q7itzp7|YhYJH zRVL#i7~Gf3MKI7|UGTX~Os<2$t+!s@%-DqAuns0%z(afoR>IIv!~JdkTA0im*TP1? z`9*@k3crR=uDu4nGR0Nd#UrwdtFwzok{ElZr~s^prP4A4Nx6)jGA(1LOv~6Q)6nJd z4#)?8R3nz78i6V1=K|<3Cxf?t*~Lija&a{Mv)$`n^+7mvs;uFftVNn*T^ z#Hpc+N~YySCDZbvl4*HS$+Vp8$h5p5W%_@wFJ9u}80q}@qd|tu9}UvQax_Sn$}orehw7pc_Ka4LDUAK&rIKK{te;8*r*L zfK+MQf^G;wH{g^TK+0`W&$MVv#21H`$*pzMRixs*P8oJ;Am$GMb#tcoeYSmx`q#W|(R66cgIOPup{ z20oh366aF->~T)%191*zFplCEOdb!1FA?VgVwgN;6T{>&n;0gK*~Bn;6k?2Xq8b$E zWLm~5nU--*re&OyX&L8aTE;n<{@?411C%&MIzN7#%aGw1^G8!THl~}(;Rj_Z&iUXE zRKzm!5Xi`bpyHelK{plWNGXR!1Qq9e2)d~_N6J)bD$b!M80Uynhoj;gYE+!_Ay}G< zbEHgFQpGvc1mhfWsx%enP^03U55dw@oFiqbG!^Gi6O41jsnS%OLrrF!3&^Vdm==(! zI2VwqIEOM7=X?m(Ud1_5rfRR^9BP7bjyP3&igWVf$2f-;GR|R2#yL#MIEN`2=P)JX z9HwNP!<3A3n38c0Q>i$IB;p(3Q`$+7!>>tX4QZbjv z^b2_%QhY6BRDU9*N}K7%aB~FwVon{RF4Wc1wu;s}QuisBgWJJkQc9maCZ+V*V^T_= zJtq13Y%xjcvcx2%%Mz1(-GO3KN}oL@DLuucB=iwHPcY`;*KjcfnLMp_4M1szvg%;U z5eHLNA51wiO^FdpRFWc=Ov|Vv(=uYow2W9XEhCmp%ZMe@|9gFL=^T#{P9Ar1BwHnu=7UOjS}vD%1oc6>+LG6{%38B9#xp(p01(WvVn4sZbM) zRK%&$RHQ;pW~2(pRHO>XRHO>XRHQNL_| zs6rDNsxT!(6{cjU!jueEn3ACiQ!-RxN`@*-$xwx}7JRw+9rvOctQgAbfo0V;1x1^92tMo4tBqcxLz>aXQM7Ffwy=N> zYvy9#tosKSE?qoZY+mhDP`v+lc(cKVY+xPGz_oPR#|v9~v+d&*mblIt+{ZgUeIGA} z+zzsjH{Ca553uu(d^v+=V(^3lj!|sErcK)(mv0CZL|~h<6VgLs^RyANM~cLlZP&0+ zli`sNyd5L9Our{zB?!FN-5T;O7x~KfGY+Ain zaa*xep&aKkhVYSR9qz`Z@+iFqyMYm(f+Z+|J-RORB&idh(jZ+VtYAUJ#M9bRT0_SY z_F^l1>eWf=p?J2jhn|dQy>1YE#@nN_=%EVhQH?#c8R$ggmo}R-4XcFf54dmT2ze~1 zH$=OuYvy0umw%E`gL%l3BU%soE6khkdUYzF|=xuBXmW zM4NayeAeSJ!u8Y~(*E_-NnS(oHXy?vY^*&LN|4kYeu1rax={$l(2yb`5!^7>C3rbm+vQU#KoE$?vS9 znW3|y^bh?LTM_#wYyg7(c?x{SFF`xeKNZ%a8hb|<(53ayqohps$x`TDXdz{)ccF-S zm+%)IN;%>ct+K{z7`lWg#}L1~kfNG2-3+9Y$kMcO%$l=7fTywq#S-LH8!Sas*#c{;90^SvaEE=@PR z3^7p8mB{`fU7qH-DveenrK-CoO}RE*c}1G?%5>#b>9{T(*CPh%cQvwVmTS_Dugx&N zE?vDL9j`}JS#8Yly&>KB#x&zi>B^hZ@n%H74gGOmT$Z<_<+3?wcWV%E*iTjMwxH_v zG}RqJ)ty1OE6wiiG`c5^?nUZDzefPS1#&TrCGavQ1dTqRi7!TEU;tr5L=h771A!$2 z2}w?ehsi6zx*i8LL$5hXWOUM;A%O6sVbCd(ul7EaXlJ{_SIpehO~&0aEqko zG6$CDlD!^Z3pt6c0rz9xI6umwd*C3t2M?lqNb2OfFIYcSUi@KH!8yyOd*mRxM@g5p zo{ymt7jN*W@VOjr&ZacpJK`b)BCJ*57f5ieB29v3uutSFP{X%43HZ$JUgY+T8#gW} z5I-#-(oHDcY|d6JxY?Y?<<}EbM>DXeY0hvsL*j-`+;-Iu1=KTzr=t+=wS=+`DSi(W zTt5s_FaR6k2Mx^llbHW3y$;2?G^f{*+zK(r^j!Fe8hQv2Gs}9J$n${ za|h8qFLm-ETfF=S;`Qyj535QqYNR-C_~6H%6KbF8A6s(hLB~HA!He42w6rM4Oz+%vWzl> zETaq|%P2$0GRpWtj;DJ znN4^G3NwZhk!6NVJ@)NR*{KRmOk)M!dJ@)NR*{DdqcKXI971n#;&f$TIR1vW)zMOymc1NHL|rSM~6^RfAZ32V8p7Quq$wRIz;v&EoIk zg^4@(1s#?~e@>(K(&#T~^nMzBkVYRO(RwOQN^yGI3x2x_-ssnu{Fi#q|6hCMA0Mhi zi_k;$Dx97M7}`|KZiT!KDSj-JTMz9Te5j773pG4cM_YKP?$1{{in;7j_)A*{cn44E zPQ}AKfZvdV=uVTm;QRWNXV!P{eBJ5jrslb6^%Osealm7MN&Erp38x2j!T0t3;|sil zhaw0I_%*!t82A+L>j$J&S*0VgN~^Oy?^BYM#cXdeeoSU(Z2E>Jdu>|;EAMs z2TvsBJ9r}bKRds8bB@_iSEifuG>Lx?9~8=s1VM>>tqvv7Pazw8UtbYsfy1jWNH>Os z7hmVU+9nJE&@rHt50ObJ-@)^<{LhpasEgdb{?AqPzrqbCl6W|o8wvt46^sKi6^sKi z5scLp2OqHo%nJ zY=9}b*#J{=vjL{$W&=#g%?6lK@8Dtd#ivp)fN*MQvqLeW!xy~51n)56*YEJf*pu>W z9(~O%{Td?oXz&#)RQ1qk5V=!43fY*Z*9k=(V*Gh1q5e!r1@^-s>Ou{n8*TmlaJf*8 zqebj~9Na|g-WiO08M?n7MEB7_bRSEdjNNH@#y>%oiqGk~T?f(qjdXI2D$UP`@0R6d z)qN^;GIpo?neoq1c{=n&Yz`Rk@N0PObMTodt;#ALkyToqRXS2i@xsSqj9F9V&)pEn z@JS$JH-U`Z1afQ_0RDK@$h3^zGA(1bOv~6U(=v98^#6~-Q*-&s=zoRVAZqtG-p>YpF9%zgWGem!WGem! zWDo`50V(CDHuRwZLhz)j4Sl3EQ=<%pZBzupwnQ1WWg72gnW0{O|89FE-b^n^78!L4(9;fN# zc61ew({<1+fmofcgPDZTWv$DEgVg0LsgvLRwUG=D0K(n_1NG>_t^&7mvs;uFftVNn%xB87xH2 zWUvrP87xFn1`ClKnL42Vg>D$(@Gz+#P#{c`;JB4(CIey6OvWgbsIBQf_yZrY+|f=T z_n7;ZA_)4B;g(i_952z*fAURfbi#RzL?e*40%>_?l+{HJu~H=?G^W)~b{~S3Q#;v7 znQ~J**-;bR$xfU)Cbg3tHEJij55dyZPIgkJN>e-8Q4`$BPMj)D?PNzy92fZmfiECa zfiECafiECafe&RW@c9s|y$XD!Ox0fPWJgVKCp&Sf_G%})7_ttdvn@j!8cz|C4^ydx zZzV$;>SSoclniZ{lKa>(B^pHpPNZonr8cr-IK$0Q52LYIx-KmdzZ{Fdpix>PqY(Ux zhKz%-xGDeXb70#}W*n5eBw#>?V3<;?U?|lvri+Lu%<7Qh4?)@W6CstkU*cZ94#m1O zdkW64UWa~SzeMwbf`TTgzZs#{jVnZqgufOqW8~+-_>!Uf;vl*&52E`@>ST;e%QOBp zs#J_j*L`yk-5%1(7@6j0#J`p0Wz~Hrbuvb#`*o-V4p)|3BSg4?|fT}|p)uho3B-pSoGD+XC zFY`^J0c_fq25Q4T*{cov$Tc(3)<3*i2(S&?x161x(YYDw^N`iioS&hsOLx8?&A1*3 zHp){;fergoQZqNrd>&GuV)KzxM|fd6ETywq#S-LHQA-h3 zb{A(DFH1M}H|*0ftw{5|B#kaj_q+@-P|uaf{vlnS=D8}3RwJdVyCzM!HeGo|n)1qY zee6}mu7ccP~~sf7pJ=Bj-cw!Al#Lf#ocLiPa55ew2n6H!>{nngv+%a zMhP+P#cwe*)#FeFXM(oz!(Y(CHAck#4aQrT= zDhdzSsgEB1?ip;GQr2h4Nqsb?!I6l+d(37X*}g;j&K){;goi%(r?{uVX9aYpR&yA; z9lo!I#%(p^oaE%`6Km1p#I5jm3Q;z62pj#T_&cqv)d@rU_XXVy;J$gF>octe+Y0~b z@OPqywb&R6A^fa$#=ks`rMH9sir_z}6|0By-_m7lFQg;zADFNT`aT)H;pPv!^vT5@nx57MxAAxXoEVZhM?PW8vpK@p+B-EEMv=BK=qF8k4*3;DdnE)34;p{c>xzj}ZOG3g|XghIC z?*ln!({=p(IE` z!@@`*XmO+ygwBJ`JzvXZzY1MGyt%DG4*AgN16fP>`-1a8HwVh;$XWq~fL7)+HWdCA zTL&mRmnDR*9R7+9=5i$TlaBEAZ&y*mDo4^Fq0@4Z+Ov~IE~Vf-6y9^4ENGmd&g>#V z5br?OmE~zzUNb>G*m^+_{Xusudq@xrXh3~f8yzhl6V#7gu4ApSSvs?JusU#HXCUI+hSpP-GMs7u@-U8e#Am1OxD!6}SVi=7E029F)<5*h)HlxJn%l~;xnRAIKu|(9Ngkc@hYsh0Gp~tM`cwAU> z_~p8PC@EpD@nsg~Jln*a@$+&%+dO!Q2dc@zIfIf814uGD9P?joWEf;LEETeK^!7~4nG&V9jZ z#L8RAqitfmW;JF>Nl-dxjoE5JYuOFXHqbe((Q+-D9NhueM!1bnA6v~>D?uySE^i3@ zP0I?RyB(yD+oI)4cC`M5)q;H~sp;6r5Qw0a?WJy9{>kz(3?c_^EW`u`IKlW{IGW^`%V(;?{+ZCSh$|vnJY&_8h+u=vD zB}BIXbzzSYZHYSkDE1}MR-mq|yt{0deo(V+Y&6keprhFaqP9>%ceaygG*Ay#+(Y^; z0P4v`6K!)Gehhn&=r2IWvTi-4WiiyH7h6J93RJ;9CF%~j^kyewkc9p+5U3Bkg=j6% zaSSqof7qVQcwbg5Xe~QDGG6P)Mk#8|Phb}ic{z=Ee|8ViQ|1te#ZM|4ubsp`Q&h$W zuwRL4@*DAitQ}0du`aKG-yn7hQG4iTgV?!5n}u!*(eP*|K8SUykbZyDyYo}nX+-bo z75r3oBT=X5Z`KeN?;|ZQjSk?avEfABom2TRb^+07XE?87&k+5ljp8F%15t};V|E6M zA18AO1C3ImgR!xI~VaJP*0+Iek&Wx&LGQ?#%w;8T`hHNSYACJ$DSoR0cbq?Qqc2k zh20kBDBWvb|Ig_ z))OT_H;vsxl#E`;r?VG)OK%yU!L}1MxXXBwz3=N{%lJ9$Q=$auX0g3Q$>=hEF56F3 z5xbn9&)j~pE|owRutK7I_i{dmwIM12n#Vd4Rm8617qa7&-&K4e8?G#`;)~f7qI~x% zzJy&s)IWDNznCplbUk0jRtS>kXgRw|&|+~`mb2T5@T{z0FB6UOkp4vUq|ogox>e8@ zMDsPY{DEjh3`siyk9M(BBPc9rB^znn%vZ3Jh_HuT!iEc)&rXIjeF>XK)C=fRc8j3J ztj^n|U&fwQ^try0?Ih}#^NoHv`&E$a6RTL$6S4H?8TN_Q>_|b2*;M@}eKi|QI_yiU z*)-Cvu=j&*i6YZj!){a*GS;%E1Yys*gI~#Z5H+}W@OA7fUl+TBU(JmESo&Hg0lI5h zAyG1V2j9SsAS(18;2T*_q6YT?ek1Ge>tYY^o7m|@3DDib#t|i>4?x?`@GZTq{C0K$ zQG>gc-^rHvy4Y5JH(O1V0NuT815q-%m2Y9U`tfIHN7!3L z3D7;pb`m9{&+^CFSH7k93V)LQMAYEE!k=c=NwOshW3TXMSsqaWbkDOEM9JtY{6%)S zZ|QC4FS9O04eoaSD(mg*V%z!aY#>nrbZ@dMqGWVC-_9oZmfpL(ft^j%;J(Y>X7#=< z_AY;iEhS2T?$2xuQ8M~2{|md`xAb=M57-?<4en09lRfO~VmtXq>^Y(Y=sscFh?3Er z{BP`i-_qO7KV_d0HMqO^=j?l57u(IhWZD3~zwG8;vj|Z#x|{D|g+ztk*Ze!ynyA73 zn(t#r_`2BF{0G*ZC;_@3+3`fl=-2#bHrTiHzURNPGl&}8@A-Z<$=Aic=S(|?C;>WM zn@5z4e$P#9IZ;LISI)I-i7J5{?LMLs_gC&}&k^MVg|!{Z&$M&2UCPh2bG09orD^AD zW~FS264$gFY57DIG0!g0iij$KnrcT7<-^~1Zl?8Aex7}Z)?fMM+by+W$}it8)+Q;x zeEU#smh#KDTWbrIU!i@Nwo>^O+HviAd z+nuys%CFcyQu|K%wY87Zeph~N?QU9hplpeJx2@e>JA|kNsHb)~QAMo1eXMpAQ6*4? z)=&AhxBF;AlwW(huQpowb+P+t3FX(tK2fVzeqHR7w2PHr7rRosLizQy2Wht{zn=DB z?Fr@A(>_&uOZoM*Pt$fQzrObA+Fs??*B-9vgZ$&`Ymd-!h)UeP_8D3;qKeo6dz99e zs1j(j)>Zipu*YhBmEQn+ymksv|JMQ7X7v?~?OwiDV$MfLV{?RG^A>>BL>MN91&+LMYdwa?aG79?YFQhQsF zjKxXqQzDGTwHiMeTWPU_vA9;tBf?l*s~tjwvA9-iON6nwR_jEBvA9+{h6rPEt#+cI z`7kq1@>=a&K`X^m!>Mw2DR;`6l&NQbfbeCa;f%g^UZduLNN%USrSE zj8m{YoaL>t=V^sRg|RjEh1wBB3D7Onjweb+*Vv1-YTwek)?T7bB5H82wJ+9Y`nuS) z_Hyk)q6FwJ(Jm!QMz6Im)2{X{y-oJz+ATy4?k0P+w#C=QHrZ>nCy5fEyHb0VC>h;k zuhZV~Exp_AtF>K34essswc2;SE_S=ULHnI30lJM^_*8l9$>{C&jang5p?9Bslh%f) z!M)GEMeFG6V)xm%YR3>IKzF;=pC}o<&%RR|>RWn`*mrAVh#K5S?0dC@uZulmZ_&;p zN`USGZ4ps2`iT9Iw$iusp0Xd&t|4l0pRym*Hv78RQ}*N9{X_}SJ*hoKl#D)QKdrsy zTY4|r&uZ@yHMlR@&uhDUUF=2sMeSRn1n6GYej`doU$kG<;5JP3kV5Yb`*p1`QG@%2 z{iasp>tb)%+qHH?3D7lYM-wHZZ`f~Z$NQGv+x9!!V4?>1ZTrt!wXci4ZU03(izorQ z545w1lF_&Ao!SMyrT4!5k+y`W!F}KUL|g6aV(;63(>4$#K=-M3J5e(FzWurO5K%?! z6Z=c;Wui);ueA?}O59KEJ=(WK`9R-k#%Z!8Dq>&S`?NfwN}wOKLy7X;FYO<-4n!qD zKWoP-zrFUa+5qLZ*WRyHE5E%q(PYlrg|Px2~ab= zB~e8z>Kvk%5mf@U)O#qus8g(;sQjYNq54qeSKzeP$11-9=P*5~{0f}7K3Dk_IHme> z<=4U~*RN83Eu8lHX64ty>7YNL{8~7j^kQ3+5Vy`S>y?DW-#D8J55KYg6?>+GDU&rp7y zos;x>qW-zvol1QX(a_uqXP~}H=}vG4=~pY=K<8xrCPhP>!TQ~bs+?2wM--juoT@*o zXo53De_hd3=QRBtMQ1xh^^X+Ic23v7R8;Q_(|-^oWASiZABL?YS1X3=jfgN7SLxj( zLEO}UmPit-6(jV!iEy=|THirbALZ-}eUBiyc5#N@XgHQ2?^DmvD~T{Rj?^az!l<^u z8L3}D)Zi{~&eT`=y4V6|jD9Oo0(9f_r-+i#1vYn^0txl^MzBC3e3a?aLEh$?|<^^QdO?kZ=dek@T5&}@Bx@>}Pe zr=O|();V?hEM>XQsn;(i%6Hc}bM^uqg)(iD_iEb6NQ_xB_FZWJopL=Em1XQlqBuZwMQR_VVJB|x`EFE|71f@gD!bA{fHsLjlnr`bZ*JFL18cC;OJ(v(63rOd?n>a5m}leO>HX z=VpBc5v&(DoAs-RV7xaGuax5EXjwI#20` z6Ty0c^Nilb*Tvp-p3{31!Fqx7fb#{tto%N8{-nR8EI)O2=x-C1xSu-j>K`k=Z=Cn^J<9JJ=Y5@xl1H2G ze&c+oM~F&*{;D@4s)+sIe5|)6ss!4lcU68rIJ@<}%I^o~GyN3h_nY&DK1%uh=6t13 zSAM@a--vgWv8_wo-<)stCCbkX?bX*PKQr{bzDfC+p}*_*62X0c=qLRN<>!Td(O*@5 zUg$UdFUrpg{jPte{JfB6{Gj~uLxy3TDO;j4mLIZ=7*W2PAF_>Nq7tBx(T=DhRv7Y( z?#iz)6fsUxeubf^F--XthVqQ@%C9&SGtO0h#i7Q=a^+VXYGQ0qe#N0eV~g^OhngEt zDZhBAg|SWf#Y08L2g)xVDlxuLen*5_89yq&BSLKqXS9Fbj|jCj8WWYcM}!VH4khXj z<6xOlN;EY0s8G3aq|)^awKI-Yx;~-y#)(RIV(19tRHYjf>R_Cq=(JEr<19rZLY<5m zibjVz8|N!JD|Do>L{TEt#aOARHguG+UXYB%U5%Rs$x*+n@c28KIhQU8M>K|Y#+$w_c3$WNV>eL(bp4I}M9JuRp#etYaab43<-*WFql5^ag@jHv+WETJ zg`rc7qlw^INN9+0JP|w#2@N$)@h!cjp<%{Iq6T+qsLGh^>taho)y7Ps1n5Q@^NEtt zrJ*y86~3i+S!j%L6;XqGS!kTG$=Ag$3r#TYAxeO5qOp}I8NDnt*?7sf^sWd^HU31@ z;9e0*7=QJ3u`5C~##clM(4B4kM3jtP5vnz;@qW8p8=7h45y5?bXtvS9*Tt?4oo5_Q z1o!=+I-?5_-1mp-jow5Ru}z`5#!#Y4p!vo$q7rvgXn`@0C?9B%v0C}v5xU5@UisY- zT58;*Ebj;{Gae@@aqkGNFkVr9TSAu_?yM0vFRbAJhaXyg+O z&DGqU#vw{)yMHwfQ@V)zkd1^9y5_ zpp~$4+1LHj_)_Xvue@8?H-QnAyv>^v1f4%>hIW z?pU{pIn39^#=3>(IHCmTnwvF5$>>s8&NVk*==h+=v#U-+{4Xhh#K4(ZkhRpuZzua+nMhXB|vwCxtk~%o#A#g_Yzga zX1kqDYpSeSB~TZ$8BvKl+wE$W6XgRPZ5~Th5u5AwFb62Vx$ZG$wX&S+_A)0CmAG@= z-sVi@x7a<-yioZqc8@nNSAL7#6U^(B-(t7FdAssk;SMk#R(>nof#yrfZ-slZ`L^;~ z;htiCto&BHL(DzOZ?!wr6x*v|&XDh}c88gfY4X@hfU3-9L>001ZnfE#s1j(T*_9~Y zUGJW0_EmoC-7)4V%5S4P&K#xuHo6nc>B?`TJJGCDejDA%<`U(%*_~>xQGT1&=KF!@JsSuE_PSF(BWexQ#=G7eMs!nnI^SrHS2PJ|0nr-J-DqA$gnOHAG+!l32y$k~ zJSRs=*p23BqBXE1>n8IuL5tbz`AhW8<_1ABl592~Bf>~>tJy$=vEx?rTS04`ideaK ztNA+-tjv11n~}3+%U8rYdv}_}M3q2yo1KaJ=N5VQnmrWt@a{8@BO039+uLFe79{r; z-fvb3l4s?9bAlk*y7!ys5@GA!Z!VX9qIDlIuM)J@Ss3fBJz#Di-OSK6`UB>ZQpd0* z9yIqz9gBxf^d2#dBp$^XU%tr@Jv5zHma597SHsv=3qf9 z8J_89&1a5aCD4oJPNM#~gS?l`PZcG-SIj+vWXr#5{v=4Y{HvyQ4wffd z{#COn5w`rRX1O5QuU|8d79?B#HM4?r*z&KLgCw!TLg#v~n`4Nut=}-G5n=1TVV);Q z_Q*HPi-@pCzG5hXY)%%KLGtqv=5Hx7t@_3k9Hq_5&mTTA&TxYbgNv^ErwS2~za~1V7+gX<=8f+e6T|=}G`e#S$ zHbtw9PS&G}mK$BHmxL^zrbv@RgR@pGWHM-bliEb>majPubCX@v*x z?+{hQR(nINBBDy5p;kMh{<-VDVOAGK*L%aQV+6_3w94u)XfezZzB8(<)5&rW)TPQA zNi<5(ctN=T``sF0eQPz)w zV3Ebn2u`VO31R7^ur*sc_ z6Rdlb?jdiY^*mAk+$X)s*6WI%_oi5H3&JS#syEg8KoH(fBYjSEtDqlzh>cWDs1-Aj6AqZP=hd0fdDs^z@{i;`EEth`Kf^}w%b&H~1`V8w?qJBB^ z&9kkYf@BLOtzU^SI@MZD>qY5e|8A{yB+&}nG-|EEiuUX0SknZ_Yiy>qMCn4tOly-M z>~$Y`v#lqH8r+Y(^Q?D$UF;*T&e}_q0A0NmnS-U{leCY#xmH`ELhlQ2zSV=M!TrKp zV4dviVqbWRtZ_sM&|PHBCQ3%X@RnN3d`oYyx6HbZsKMRqt+4L%b+NtPrPd2X3DB*y z-Xlsz_j;?WZ+uJd7jKPa%$4#aIp7c;^)SeFtdK)1=dfhZX@!Z%wF`j(y--fX=>)ZlvI+pG_LUCayL zVeKVKfbK5Kp69o&7rw`8PE_c{!uMH65H+~5@cq_tzAhFEKWGgjN`UTRYbsGP8Vf&a z&Gjw4=Hac@DxwCrdH4zIW?vU;9)8MtlqdnZXRJ4flF{bj=d6!?ORrV<1?%rb4Q{LO zOO`jE!9VCru~y+%tRkWW=w7or6D6aq!f#k7_?BK-c$;-PQG;6+e#@HR>tbc$KUwDx zB|x{sT0oSHmWAK7F83|HBg5}mHxV_sM~2_G9`SXtBf}qBuM;Ie_gCv9qGa^Q@W<8< zzNObQybE3xmdDWG_6+Z~S`rn;dWJuiY;{>mCbR1xbN{>G{yss#Gh zT1W)@IKz9btBCS}zPIjFewE?BTTd&$%J5It+sd*s{EPKDQHfg_{>|F2{Dy>oxAGUr zT35z~gf)H`QNBAQZ1CPG5q_=m8xxN5 zdzIgqa2|hN`Hcz3_@9;Em~dnMwep)3Zo>72emy6J3wZ%izB?)0oR<=n0JY%95>>=% z!bSX4;dNU#|R?hmYeoDZl06zyP;lAH${uvSO`>p2th;ZL;HUC|Z-1l3}yI+K@B-hK&;JpRS7whF` z^5KHydik0B97Uh&qxoe-xYKtGzg>`w+GF{PL>RTl@lVJS*UQIowgk(Qk$D_HM9^Y* zpKCwpx+yYYHRv=&A!7nRTM$O=Pr?)VMMMqmC*jHb8ebRtBs`VhN0b0vg1i}Kd>$_*D)jb+>v%a) zgS#(W&%61$*uL;w-j^r=y7_!CQ8KzOynvtKTYA5Q7xBqN5VgY>@manu_DgsvUqA#= zJG_ivMg&niynPYH*y0nA!=}QBb#_TUl+@b z+{}+AN`P)NKb|NV&5hi~Pw_3iCXqY%NTLR}N#rg*+1JIIMDF1;i4vf@kIyGcMw>+L z=PP_muVv&xeic!J+cNSn-{k9JEhCTedx#RC+sd~RC8I4PPw+duLxKa8jZXfHpKs3JBv@;&dZ{02w<&QDQ(gCjrjQOa*{=)CCYDDM6=f@zhM!>-l+UWMJ)R+Zmn3k&14KbhnRHbZ4Z8eWIc*5qQf;(Ib&#>@yTS89CNIOVRU@UiJ({ zuSP2D^99Lx+uL3&2=9wuvwGW?3c~knkk%4CDRkEm-74rtqWKzH-bOSchIB7cji84G zVZ7ZQ>1}^6NXFYf_ODVW;_dNvqf4;`G2ZSqkGDH0+NJliD+S32dxAZQbp3LEG*7e_ zk`Ci-e|rPzFy8jJA0r*EGxWFLAsxos{`Njarg4&;dzma9pHC04+X=#WyCX8tK8~ot z-4Qw2uJU!U9g$P)8lnW~hS-aUlF=QJq4s*;(%TssX5T^tZ%{_6?E8IPY-gm}ewqm0 zpp1;P-yniFC?jXufAKB7-H|c&r$q1uWn`Sa&)3CvM<&=Xk%500wRcA*+F>GigEBJN zZb}4iP)4TOZHV9v%1FZQ(bk+w7Z&5}>=ozK19o zZJKkJ{TNY2tSILm`*os9p!@8PiAvm}ocrzXiSmISwCz>0T`FR2a~`%E6IB8|Y9B@f z?_uU_wT~o%_b_vwu=^;#_Bl`4Co8}9InUTf*X)~=UzeOW>@CW#XU;bJDdpEQ=dJ(K-nYQVQ5<>q%&c~MR?^Jw3Ihg< z$aWlT!0#Aruww~JwiRSsAQ|I}h*(QwX~RC`-IX7~5OWDfoIpY#JRIOK2?PR%33ree z;dSKBKrYE~F&}yGIKrD8UoMGr3Aq5@zp8tBSGLSSLVh0?wEI(aS9eu)RdsiD&rZ)M z_ORhw=sgm9!tgEh9*zCn@GbFv9Q&Q&TjKpRCO@xiPsNvbkH^MoY$C8HW0N%2-0(r~ zsn|@7bpU%hw%G7}(0ex4Vfa4iJs(?Z_)hj-jIB3(Cwo7SZ8Ur*doRa6Zun02ei6IK z@SW!UGIq7$JI(ub>=wg!n)jR7w+!ED-fv^O4PUSKO6;eGuh;wU*e?uUulH&U5B1|i z=aYNA*JFohthr&pv*dd<)&b0s@7Gu=KH$~J7Q;8-#pFuEm-k%xSB5X|)yjjF-3I%D zcZhtzU^~4-<-Zy1%iehTn8E(eJ4`-ju)p^Xm;Y(7Z+H{r?-^4oWuuHjiYQ;N3o~!D3#hWOvQ+)hhhl%oDgB|Tml8NkYpfsGbZK8ftrO*LZ>Fr**qXZC-fVfO#`=NHm6J6# zC$Za`CueJH3b5nkVvUWjz1v$LPu19-_}$(KG8fi0-0dxrpU_wib&KVd8Y}vDdoA+s zL(1CS-V%A2#`eT_du{T8u&!aZw@m&}V>#5d%O^Be^mltF$rnS)+V6WSceA#dKUh%fe4TkR(@6+-e!zcU;<);jv@INbe7(U^DPF`>Lgnx;=&G5ziOXXdL zFXmq^|Hbgd{2lT~hA-w{DW5TXo`1FcrQ!4ZYov9hvON{|{A;DBv5COGBoEhEbHh0Q zdO1~N9l&mo^9|oP|0}Z1@Qw3tmZuoL3H~jz*YHj7ZS`Lmx-&w zexKw2lWf#jN5dR{x16rARD6#Apgdk<6M=nKE;D=!{O`$b!?(cyf$TSY3;c)W2E(_& z|DilbW9^A%{}Fk<##Sem`u|6M&eV1IkIE}e-6{T$dpt{}cIjgZ2AA zmG>F!BmQIZy9OKbAD544tUa;Oe?mTOu(SOq<;w>9xc~3+w~VQku4o;QC^_yXeD`3-e|Ch^OF3I!CdF( z@+rn>ec0~5EdQXfHFewlU&uqQAzdz${lI=H=V)xQeX;**xkzJc>Mr(wBbOV>i~Zlq zE{%<^-R{34^BTj`7yf_C?O|QRcK=m*oyPF=h5x#|M`L*U!nfR?gp{=x`;Pmp#`eT7 z_G{e#4C@*$_G9jUYb=L4*Tu5VS{MC`{aQDvvGKJ#{Cc-hV|(H|eBYfG)-~+#lkPl? z zl(jeb6WvQSwkLjrKiR!DtZTTzpW@!4u^j4-bib*wqJM)w&Hbm4vUZn$wEM8e_QZGj z)7{6zx`ti;O!q~Ne{T6q1Sl94ve~FvcSPpeLdd)fb(`(K7{uYay9zob0T z(XiM5xZ9|)iSfPudG1V&rGTC9wrH$9@drFNwNhiN6L#WL?iy1k6Q6d^Fm+zy0{0^Z zJ1B9XTQ=BXiO;y_7_2GrS@)9$dtc%r_hN$`llYu_mB!i=a}pQ3HyLa};u80EgDp;c z-o2YK71=L!A7YFm`;mCh?Bk57(~Fn7FKIqHH+rf2OI=5&7cX^RR~Sw&wk0leQ`eD~ z)Jf6H-A0Yk>BY<4qZm`s`*L@_#wdDU;kIc?I=y&>+odr&y|}|o8|)nC3vNMUbb9eh z_pie`oDRFjy~tn}I6K{I40eh0MfX;X(dotO-EV7*R*UQ12Q@~g7q54JY_J=h8{HQS zcB^xf`#Xc3i}$)0X^c)U{-b-f!Tt-_%^IWAi}$;C8teh*pWW{n z>{jO?_i=;W=zP!p4}+cK{J{Oa!M^7Fs~i8avUYFuF6W2tc!NFcJmO9@*!|9IyK7hiCnG1%dem)u`#j7~59hwI#+tj#2jiTuJ% z8f}<(TX&_#==9<%ZjZq(aenV+4R(R^s(Y5k==9?2 z?skLu5fQ&aV|04aj^ALgPuh|A?HZ%gi;?(!21`dG@gHc6PA}HPA7f12zpaVCsOxA? zR1^QL#_057G#`cdtf0eP%2|BNsjDJUCbY3wTe@0_;Ua=v5 z%vVTjb>6!n{sqQpML#JqE`E!_x)O)P@6;I1l_bW;AJkX}u*2hzYOFnxPBg}!G}u7m zi1_o2sfhWWIQ_4H7tx|Ej&QK#}RqolePZ^}n49_^11{gz{3{2K{O8lI^s6=018pEf_r=` zdnt-Ovc*-*rP@+32Txie6DNICZM8qE^PlBjt7XZjvE;X!|1pou_c8BV&A-*Q-YUJa zl(Tyz z`2qjU;*WyWvGhRsu^2lR)BZQc=XY~_7_g|JqiLZ>58y&6~+9&0G0S zlY***?jnuWN;Qqr@CnxH-^~3%TinHWpvruo=s@}(NVjTzsx?vVDjQX~f?L_rooLY( zSHf4g*NJ>YRP<5zacuDt-+v@7TUa$j`ASuZ(z%+ZIRuob0e zjK=^$TWsgMWBZpVKPVfOhp**6`a0i(J{MfJzMDCZ?-Ub_BQE3FK_!-`lvn4gY3wTc zFt2Pm(0EW@t=3JAXQijgtMQ}m@u~b1tW`Cvv|@=jo+(O`*4V!HVXJ5TV{o;t@AlF? zUt3U#CEomODse9;sC28|hp7A?ch^!$Q&(FRs}H>YsnDpqrIt|bs(asmoDS7%?r%5} zp2+?g%a8ftoiGNf$LCo7-LpS@yZX91#*)lG{dcVc$LH#Gp%R(LPPW)$>~8Ek`EKmn zHP^=EygTFbUs8;9_;Ugz*u~HcgDB3tKa{U;^f=qlQB7Cb82i1{Qn&T z@3gq|GyWZNChx(<@?(A&8w2mmF`(iG^^PU}6sYc;j@_?R{v5ks`ImUV^3QRP(iJ`R zmPi6d#dyHDmh!u=&ceHt+VR7L><#_&@hvXiVdO<@E|eA*?|0OwN&zqwF#8}ZfyY9 zS8KNdPO04{lGc~~9f0(I;*wTR{dJIhas5qVyI7srg_3Lh+c|$H=zo^F56^-BB=ygb z+*AKA%=U7ARb8U z1RQoh46YwI{di%_949Is6gN0UYdh$l032WYy!B1-s(mEuGu57G-52TSwvI(Ug(ui2 zTF2H~BXtl@Oz>75|thcf|5XM*P-Pw(|W9`8#acmd}x0i^eKB)P4mMepe#cq7AG z84@qOhlAi<4DV<70KHQi6A7_aFq-D{2G?Es*KZD?Z0n+<22ol%cC`sPSt?Z4G z{Jkun-hV-PlDRiZtGMkKAvVkC{;6Opv&jSvLW$kQ7jlH5m0 zi{9}-kjm+u4oQpNz>3YtLre3H}ZxG{R@I2WGPe2)+gy(wv~{Ok=+h zv}&e-E6Q-MJ&k#%G4C|yCHNZ3iI<@3NU>EMR3pVUF&^*};t0S`ipe!L;@Q+14{`S> zz=?oToNW>1xmFwC^l_A*J&y8iQz_p*wXJ3bc3!pOiUg$%;#y7*$6FBypDZ5a^l0%q zr*p+2Nh&`5v`#;P6I369#?M@*(;HMuZx*5Q z_v-YSMV6v#Rw=@ zs22&WE=h5?NMT)Q5bpstNgOPuh(pAY;!x;49-1E}=73^8C>D!Gu~Zx(+CkX?uljZl zXRO|n+yMB069hLzh5;K=RDJ~K>lj{TZ$ZiV41425d3lQ9?&vuNuB)Z|cerF1!}BaE z`EUcl5<^A*<|!5ZccRqRE{1QegsjL(rC}w1S;JqWe2e=xfV-myDks}di4o;GhP$Jm zM*cetcQL#?LM2x*yt$V0Z^f>QNOCQ~??egiVtAfK`42Y`EHT{8_Kvju^UOtXSCruB zR)ix)Vzl55B!D)?Obq#2KpW%6McxCnF?wnNQz)}Bf_y+4Q8;}H%oekdTG*M5Lw*iM zl_fAEkv|h7%Mu>}v=IpoNB(?3oc+THv&E+{zHI#4iiv<1U{2fOLX1gUdXC0yx!P0(i0A26&0R4Dj=IJD}y91WFsw7LKz5@Gxf;N)89K#RTVM zz(%JF@Cau$;5=syYL5l9#c|GB!1>OH02er?177Cz0$%Q<0k3fS0B>>vz?+=`z`t`c zfVVhj0`78hfVVmYz+)pD0FR550Ov=B0T)Cz0UjUO0(e5?EWm}4vjOjpd<^iO$hm;` zMm`RBU*tT%e~g?DNNb0U|10}xz?PZ|0Z**?EZ~xw&jH?Ea|z%bHJ1W@t>$vT_e6I9 zHbt)loEW_ta8mRd(U0EjvLf5)dbs*?62HyI29^5M)@;Q&S~}fYU3RLc%HUH)CTeSj zMk%`&QF&k9n{ld>KW+KG;+COurjYM06tbn>S-o?6XNff(y{Krw8u7tn!*+ROEG?OQ2{BcsSWwtB_4L%@B<>HBAASm~)Os^Ch)7jymw^#HH7mGo@ zd}63=Yr32kMt8=#f-*#03}(tf*ANv!X7`q%U`e5$^UKqvLC%v0 z))b1RfNEPd2F3J1z&f88l*>V}y0pYi8Q+A&>odht#baS9+6%L-nG)365~AsvgU{hPZ zPa~(K^ZkX~2xKLD-w2BA+s5toy7neEGrgyAHMGP>`bp=D| zVw$3WW+;FSLwJ}SDf$XI)MrWvbkG~~EL$Ef1|l<%FBF3%=~5s%(-?#p*o8s~&h09v z%S6W0Q6WnpA{(HT8x^g=y5WI=GzLIR8DVhUFlt&#r69L1yM^6eDeg`e;o+r4n7ye` zJhM^}(l5H+-#TW!MpVcy?XSPPv%+?4r);ZE{URUCUm0In^`%tG-@GC*uoVUcp_IC5apm$E_Ia)Lu=CIzCl5` zO`KbiE)R-wp`6aH$@C*jHmu1YR&A=_9YKBoRZ3ZnEJHXS43=jG27}^=B98W@5k*W@ zD(kYWl7>~Jv?c?wm|VrO$`;mrM9}nX&zm4GFor5f%X%yc71a1btia?QOlQeat!hEm zJ_|AJd=+vvg(|~RR#cr*S!h)x(~Bimv$hSx5I!=*bYUIMBEl3i6ax_H^+sw&KZ?}? zC{TJL_EpM8%%uTL9(Hj%R&B8&$PcTr$Lp$guqg6UVFoTw&83I{0-=i6?n(((L<$R7 zNwA#=hA182@QaL!zEnh=PpNU2Hg84HpFwe39)Q#g(s_a9epxX<>??L-i6^uJOC;y9 z@z6_XHKQF%^Nx*`qGn*)HX)(owgg?t!T^;Cl#ELyA9 zw+szsGkt8H=!epoyvm0`xmAa^aKbMp3CfAT@&tR4%63HKG$c)G{_H)?u-O!c0RY=KO$Z^_J7t&&c4Or!6^fl$8Mvfvb6>!lW)Ya&{sVzs(Kb}d zWYMyk+8haa6%r~NbQh2t+Cqt1k|^4vh?h9*K^dh<`By=)z!H@%-Gw31Yi0uWS=peY zfHKp^l_H)r6?BuKr6>^ggb}621~1}5Z=6Q0GYwTU^z!JVF3@|%RYgMJuk3IsvoQd= z4g(FoQY*SZe5d&*hSKnMet`3Os`6m3D&Q<4Kd1Y&j?sY*Vf!H{9Ep{S#<2}LxvHU@39NyNzJod$BG3e6sDTFXE& zx~i}leN;B1j}sjp3Pr>tiW4NJ7!KpsOd8t|4EMeg_i#6bW3{g?p*7m6l|ov*q|U&_ z1O~)VS5VxT=?nI&rqP8Vf!(>TSGyIs7?&R)?^FACvARr)at0-4Csoo@2CHRh)p`oY zrOK#MC{`7%X{PVYlHllAqCs26WZzGhw$0@rPqW_CR9&vnU~x{n~186PTZh0#>w`^+O;-XJ>ax=!r9gY{)n znbNMoj6zPqqOUQKFh(@(*d1s3GECpLS?AkJ>?y(hOB!R`YQ-t1Hd2(+a}O6)w4ibU z&%8=O@1VLQ>n^mzYe5bdWEc&Y21qGDF2NNjl@MfH4e^#7m*B#r7h{1gT6IY;21ON0 zEZjv^4AppVnfgyxrj<}VnXy)JH_~!XlRLcd=T)7zH`tVxXqyB7mI5UExV^MAUE05p zHgTg?P$A^KQFx}GK`0(|1>x@kT%rSd)r8{Wa;Y~<4CI5#MPGYqDP399j|lXG16_Uc z@DLdqB5ukfdr{q?>S8 zETm}?JyjUdZiQtPdZJX+VNRt=YA9tSN7%wvwqcr{F!#!@rR&jO3_TK;@y2lm#RGInugNc7-x5sd!Xzs1~ZV z4K*hDRIXBjBEe?tS#GXstNcgQo~R1GYd}O>>Q8 zu7j;%%Tt6{(}_}=g=BjddkntO_4TOKt}&!*a5Ngz${Wbp zx2@5UbS5OyyOlecvMtWf&V zAR@!acp7SIz*T8XUHYvD5LJmq>NQRzF9c69mSD!9*@*+;XGI$lXF zXiceesWgn)75z5B3X1QQR`y?6sE$?&s=>Z-?SVBPxfYU#Mq8=E;TQTVTua5a``7R? zOXE!~gLxiz13V(bNj92-l`ZjTD$p1!!iaD=t=@c-aVo%3w}lfmY-=NTat2T>T|_-v zCzFGz3*nw^yTd+FL8LmosD@~Ig$<|(k>#mJlOzK{Wd4B-qMoG|!X3Wq8zoPTqJ5Pn z!>A|T*bU)+idJAYq`jLvWAw2ej=#}5Lxo`CqiY>p*NpEJry!MQhO%^Ue7j6B45prwWSUX2Ud6^4t8m_}tZ3rBuKiE1ZG zSA$~O$lXauKN@9awue-djz+0uhAVPNJsM?YXBSevvCPV@P|=SjvwAmJkvbZs(sShA zXmpE4?jA#_ZzQvNw>hfJ#iQ-7)$F5n;D6j#&!zQa3C38F*A3O*>iUHAQuCf@XveB{ zVOH0v7^~ra;7A^kC!(#9JAWEG11y_lRCXUNm(hsy*3(Ob@ZX@81g^u$7oiGnWOdUfv=jx z(X_Q`6Pww_(5LiE48?Z3J`1lj7b4<(K!_R|dtzWFuCD+5U$JaDw$Xq3*K%g!*lQS( z!}a-ief6wkZDY%bt7}@*)Y`#*71Qr1OnTwW^HzT99`BnMZ78f1ktWNM_=(G^K_;0b z)Qbqq_M$Pn(QEW-gzb4A2s|eS!kFd7gl#A1CFdb;JJIC4+E|Rxc)Y&84s>w`KR(pO zBI8ncJ_O~`j;d_UxYQy`QZo%`RX~6c65=f>Q?WR;B|R_MmTYVElI?a>IG#6Q0tAA^ zwj9#29_K=nZFph>RUS06;>k9g?Mt?!JCob4Cb|iS`Z3w)K^O}}mJOI7W0BO!Xz1i< zEF$r7V>PLSM77NYp6$kBD27-Ya={!E5o#ZdQIy-ZJUHfiHa?9WnZrfEB#iLjG~1I+ zsB)6q&V!w(hYzI(V;clzEe~>R7KHPxsUW%S+DOcnc1_GqmKnA(T+XnAVW$m}IA=El zI(6`5%t;Orms78htV-sqWT8r$RnjJH*;E5f!61cAo=vuqgh6S?Vl^I{05@z6GpB`_ zo-lI;Wg;<4yMvq_bD(yV21Vn9SPVXDbjVDr(SeJpx0CbW4l7PAqW6>YFkC39KR9*} z+(jN7@qt1(J`NY+_$stgEyrq@6oMS`p6#GdWGcXjbI{4K2rZ*Qo5p0lgh})13wPDm z6M&X>a=uL!3+W3vasq*R0Gk0&k<37GFO@@~=S7=fQYy!T8-7BoEK8!}oaA!)k^o5p zXcpALE96Z(bz17QSj_P#b!n`yUKn%`XGdw`OdzVBR8OqQAuq{zEQZm-bR-f3Ct?vM zp@Quthe2n1c4`YWOq~q`6v<)KNz_Fd1tsQ#q=|uqgg6iaIuKHshZ+(|%vvy|sKOM3 zMs^fdB)6T5#6toB#DPlkE~F4dR|7guyvgC2gnI)=3jU4|rC zSTTmw7UCPj2)Y*S)&bac=*Ku=1nju{>f+vyB_D|&uZ{~_0_T2h0+`~M!H2bDiLGop zt2e2U*YJW!?$tsSkmqqd8o zkeZd6#csn>Z*Vo^G;~sR9=ci}prH^m0MJ8I@S>GU5JW(2666yw)(VU%$}*zcHY+=um7UGX&Sqt2v$C^U+1ae@RMH@qq#;puvNT}IPL>8t*~!v?DLb1H?U+&7 z*-Qg1NllQo&1@~fI?mTJj5Bl@N`^6pQHC`PBWN4ew$c~!WwKSN(kj`zD5Z8m4#6nH8io;SoxDU9^$hD^1&rvRFDu%ijOb8CbSNV_lo1_D z2}KGfWkiQEqC*+M{HRk#Fh4M5gyC04bSNV_xC1*RbgBgh2WMj6&HjF7ry z3X#?`tfL~Q9v`x(lfGQokWDvJ~;n3P4G%A!tX5%Z%?S;YLnltqSL zS=6a4>ST*Ll|`Lw5kVJRG8EbqkELy^$~CDEUOA|Pi#V(N_4 z85Ci$2cc5nM5rK&A_$r`Vzf*rMv__{95`=oJ$0|c1nhI2WK?AJXpz6#))tQ5;GY8pt$W|mO zz6`3)98`k=a#f}3%t4N$Tu8k$2n*{O)-kMQ7-#4*lni4GqYP^pMzGz5o>}^$f%;^Y z6huM_A|VBlkb+1^K_sLg5>gO}3a438445)kNrPNvE=vQZ%w=i7l({Som@+r3%*|?Z zSt=@d>=HuOX4zVTb)2td7-#4*lni4GqYP^pMxZSQKpmMpL|^D!mmDG`k&wwqNJ%7Q zG7?e}37L$9lte-%BT=?0F%YP1Wih~%tt2sAyts5kW(gAfGJfJDVUTgWi?96 z$`s~Doic^_fhkiAe;dT1RGCs{Q_3pjlv!_rF1RS<5R5U5GOS@3A$6&nsk)wF9dw5& zo9PSr@#JPw3<+6;giJv~iXkCwk&t3YsH?!L)C@6VK%ugP8Gw;6BsB4nfCXA?rtNku z=Sd{#PEaz8F^n>-VHhF(NOvNtXIKYF!E7tUrnaWG>L|9A8UqG81-;Z(XDW7qQ-#Ez z7nw@G08AD2jwFOG^ia}RDST z1?!ty(>RxlBe{KpJ*|a4oTbf|OFhf*V8HOY9@vGGT0Q2_Voz5gJ4|Ooo2ITTl$$o< zfLv3dIFQcM^K8?IoX_Gr=hKo&KT-nC%Trm%$awr z(0cC(^(No+U9s(pt|bS>nQq?T1mmX{7BTR#!!bLqF)*w#@;bh|iTsnSdV_ zAnMnrh^FR{?JqR7d5kpSR@R}guoLM>LusA}JTJe0Iniw+Fyf==2luN|eRDguKo{+_ z#Cws3pZ7ZNNA^_Fg%e1p3i@5SOaJEEi*%(}ir;_fb64aSuc;BQWU0KsbNuRqofYe< zQBGR9O#QCD6u(%~oqD?9rdxmXd9NU@Zu~w>zjT*SU-|8v3B*?;pTOj^pi|}a$^Meg zV47L@HD7(-k6VbC*U-HIyi3rUIxR)#bXKAb`UROjO0&u>M|IDG&Rx)bEp?xO=vK0v zu-#U0CBbbx?9h}e+V0a&=QUX&#Z^Tlnrl0Nv?EGaceMFc0+s z-i`1jOS}{gd*Hvg^PYu^H|MexZs`>NqDfdjCN<&AY=IuxSTt#M_tNR}CpF5YN}+kZrjBaeENf)MSLU_hXsBiP{l5(fT&2iJmQ8G-<^atf1kuL^BZc zC(Tq6%Ee)N{BM2XP3kje67!*LJcu!jr%ktL93@4Z_Jy87Kb|q#h^H-Zw){;>of}GR z!lxn!i$fo;ZymwLAlsBBxM)(kq#imhPHGy?wDjR=54dqXJ!hzmVj(j}(I!-V<_O&v k&NNN{!NQqg58R;e9DW9JA63E6hRbJ1fm=YL=+H|O9B%QBqX3H0s?{} zy5NC`C?0sM#`{=|7rHK@i>w#ws;dS?-6*cn_(1C&8e@)>HeL$hLI^K_Z!8^#by;o*iSpw&dk*v<$A6rSzml;W@&EKU zp^U=rg>*|X4Cy{>k}&wSUSmG+yg3>h8I=FCaG@%?i0J^I9I)wn;p90N0vltYyr2_x zrE;gDfp~n^WJU5^5Qwrt8JPueHhc&E^@j%Onw&hN93o;_8I)PH!KD4-4G5Tt;D^|* z@DIzTGn2h{JD9)47)p^Sb2emC(pW zNl34RiWtord9jvXv_p?aKno=>tI%4H7*%MjH>*NZJ--Tur=jyIwAGC&G%Y$q=OQgG zQi?+i5Eu2WX2}{&MlJ7g&d0&l($SCj`Dd}r8o>jPsaDGP%*P1lf3S7 zY(ZgjnOzjjJ#p5U574!UBK*M@$tACk*4Tse;mD7<-`#DrFR5n$Wa3XJETv z0jguzJ$dlqStTKCf0VLf7lT+LG(fvPUa#`Va7=7`hkj&&sFowmz zjSojb@>FCItbjszUPTM|TmVgH5sIyuvhyH+T#%VEnSw{%LWx^@YQkQ}F z2u!dVP0L$iEoBg@>Op&y7oh`|?3zB_x8j3I{2U6+>K8GK7OXUI+!i35fk2V z!DqZPn5Ro5Lzu%dNJ~?dMuS`<+X9O!Eik*FMN857*!nW7NA}Mu*Nh(uc`t(kr1B{c zu_2$V=$KEgwO{nslu4W9r;xlTNICSJB||W{t!0n{C7x&7vZv$VVJw!LLCGFQ>iSA9 zQ9*g7Hxn~J{4i{0C+5WC5NKD}sO7o2Zb_6?Ll#CHE*rRriyam(7NMeieFiU+^NPg^ zL5Kg^HOK2y2cPx^WYVnBIvOHZ91aOq422MmuH90R$WpXS{!J>5%TlyT?vskXS&D+B zW{N!eXDM1I^Q59*mZD9vom33SQXG;zLMo2WQnXDTFBLFdWz?gcn>iCbofqbYH#3~^3MTp+|PWzwxu($+#+Af>HS(l$ccMoJG!Ne>B1+vTRj zZ8OBNl(?OnAvG?fx~#9&HkjVM$9Fi+W0N`X>hnHF5pHkA@ge(99rg;^;rD6rBg ztp_(2tS_d-+`g%lU||qUDV>KX6Fbt+N~v&IM(tQ^ZYm|1BZDcW^AITo5^h;2%GCd+ z%#^zH&}6eMfF(jOr3GtlOcerKy#J{~Qb;KU`arbPH$Ul=5-ewoLzcs(g_H7=a8Xuc zZ&pB)h}rm6lwhxrq-An9O0acF(kl4{O0bnkQjpw-609vrS|?2#Bv@*av`I!$g1Jk{ z0$4%e8rfo6y)k z{}O+JkJhxHsqP3Vqi5L$wzw=h-I2?pBA3mw>1L`R`6|!`-|-T+fvs8$wep~p=-|Xn zpST5(2o8;wYlYywFnPGgo3$bAdd24!q?S_ug7ur25nOYIxC4rVY zJR=uw!;EHlyOw9evL0{e#Qg!R;Fv4!4}2$Ni}rvi6xt9*HvCuI1)K`FZL0#Dv*#6e z0EE0!m&kq&PW;QIRRa=V1Dm1ehX0sfz=v0l= z4n&s7%w8+*u7m1U$s>bmsEHL&hh4cQ!n{JZOk~B>MgyC=PbIA3i+VFr7hGk+s{A-6 z>Zq?JhI-_6H&_{bLxbcpsOU+|g0$KdwzlISw&d#8PnKf2lVjjhtT=5^2$7hzR@S}{ z+F8~fQ}8TmO}w4xa!(QDW3uNUA6S-RK8cMG7Fmh*x7Mads8~G1Lc3M41hBr2!$Qk) zWP$RG)b$}s1_Ri|@rLDtMQbixFa^m82=Njq7L^t|I+#%^=k&$U1tQ}mnNbfpKA=(I zdhK%xHfrkr8txddF3{VDF_D9fb1bM4z8nNZU<^tm|xyQ zv{^+@{Ic@l!Y+a83B6@D51(_CyS@N26qry(jG*%5)iGjE99?M^V4V;g|N8IX*c?#|T zt>7Qij}87QxY3C*A=qfnsZgpkV1 zU|S(4xR1+aT*v!BD}D}qc-GPDu>`!um=Fvr-%)cVWXVp2|B9<=AXb1^u@)Q(nY0j9 z5pzO`-9px=c#OC_?X?SV(r!sHVC0wBEh)xPt%OvJlk|LOuT4+$yd1g!YJ!=_JE&s4 z7>WQbdr!J$p;mb9e+k1;{0p{S@=q8q&`!z2B5YO*+6CDT_15BWkLATDLPlcB*&z2n zlBWmbfgjeJju$^2OPH(-#)ghPP^xzXw!`o8jJ_4m4l~xNia4z)&r$_TQDB1iVl>j7{kd|A$D*Ki@WSYV5$Afik%J3S%=K^^iQbJ_dZQ7tyL=~n z!9UZ(*kG`+0lp#*cjA^;oCDYMQ4ne|S_&Y!cs?+s_^GIa&d>&KG|=V|EoD;!A+Qkw zw0QtH%LdAVHZAm&O=}2&jS!&CPy5?|heMkyl+9vkBLrx3K5!r(SW)BR32df$#Wo~A zO|-}~(InrXuh$v$DuZ|!Cw`--bS_kSEmnHkXeq&zuaUL>M6@G}4hCy;@PFsRWjh@m zYlK-H&c5N}exp5H;xHSU-FLctDf0l=!(fc2;>TY$pweK}f{fzVfj~-w)*nF=i!x#x z!<9q!Xc=Qx$ICuAW_|y??`LKC8TAWzF9z2z*~AA@maPMZ@epP!G{J1&7j;B?n6Fay z3!$QzafbcHAdCx5)AlekrR+J5jcof@&|YYowudd*l>PFi>_>nwE;QNp78?WQhkeVG zJzU0K;huBuT~~Nd-I!s8i?`0`mfx;TMIW5BkAV*?TPJ26G)gd&w`AW~3`PJe{O$R~ zpXRb54nJ^a)euF-3+DJI97~*?0QrFhWqRP$;E8N1y|@PR2DAkvdZbJ=u7f0yvW!8=Z-T4h0LlMB zj6=>a{f_DMH{-RNk^bEv38pV%Q2Ma>{#(+A&ZYK@I{I>ML6Q|NY zOm<(Oec~VqmS4o6^j|$#`oU*=uzbVkbFf;JzQJTYq21uR&rRPXuL2jN(~WeCK1LMHsB7;9e7+(ZVyab}%xEqfCdz zFm#s%4?J-6=(yg6N$hX%;FTq{7^DNc!X7+O!g&*}ZFUpk9?DlLQWJGx0_y+ zHLVEAOVO4OTna`nhZHs6seo077fwD2$)p~s*>sO6A9K($vS@DdUCfF#=EHrdRt}SZ zeBLbkOV*8xjTz|MTyWyx%}#_!(67zFec9y$(P9vM(EXiWeiDG_-`$pk8S#@rMB4|V zkKtGZK0btTk}s}uSk^xcO~CYaU4CXclt3Y+FHfMVIDbPm~mjug9D@xFMMGFdjN224o}F5z2Hm$+ao(+ftF{$Hh@vo zM=x=8u2!TnT^L^srZ6b0*b#u4#enpWgvqik)1C6cQ0(}r@FD$?iL*{i`7~D+5c&)~ z)0-{S846wayZzJb32C;@NE3#i$-uCw1b0G440iD{&t$}hKvBe*jIPx%D;VWNfkm6c zdX|9%_C`?-=Sqfw<_!_Gs9pDVRq;tMONzGS47M~FY=7jkcCExkjV%g`LFo~0rVTHe zNk6yb1&@1vT`Ni<(FK?R<_Ogf$>?n_`}1INWQEGZnQI1MT9fpe{pwa_jqi9fOy&&fBYzdlY zN88^}FKVmH!grtqQUei39r|k+Y%8JBs$f?Omm*@m2#ze)Zo8jCICMx>S-62GYdmp9VROKBhF_!O zE8sI*I;KhK*e0cAO-jc}X-^ocm<_*p#^|B|j0wWnAe03`UU4D;u*a)UhQ|cLV*}x` zKzLj*q5pj5>B9c&1^;if#c5P@j+{|NP|m0#C}&g=lryRb{?Gas=S)n7hB8g98Isi0 z8WhT@H7L=GdZ$W%@eD`?mawT&+o)j@L3L(iBR$H{^0<^G02-NMVD)fd5O;Mp8Ds+Bo@qkX477qomCs%be z^8RZF6vtcRPTv2{+Tj^kP{JuptLi97n1b-=%Ft=i!I&rsENOBe7Axvn4f}m+ou9pa z#YDtf0h2h$S^?E!t$+pxSS#dWB@eJxP`W183QE_+T0!ZWSSygO$+bdC*VI}erE6-f zpz>>Ct)O&GtQAtaz*+%CFu~&2=!%x`Db@-B>6j*^W1EzgH7Ok@r8v=Gx@xUJAlC{6 za;-oh*9rvEmk6M>f(*;Gf(*;Gf(*;Gf(*;Gf(WM;Dg^(L%yCMQ1(9n78UAer|8KO# zwSuUlTq}s6Tq}s6Tq}s6Tq}s+|Ezy;t$@kUP=;xJc(x?9RtQFuYlWahx_?n3wN_A+ zS}UXknUSTB5W3V_AqARSBQ3i@ARHjFwxd#!*iOft1r2*}i0 zAs|z01<^aSR-iC;sk%5}^_LF++vA|EE@w(yE2vV4wE~jx?HG`21q{ix0*2&T0Yh@F zfFZe7z>r)kU`VbNFeKLs7*cBmbiuS%xEbVCeUar_p#|MZitEM1V4OW!HO(s#hZ^*3^*(~9^rzWBRM9U(vSZq z`U(F;KT+xBzISH+c&GyRrkd2j&ies%csYr-Z>r3bRi3)o*UHS3LE&iLRlGN`~b{CByQfl3{sK$*^4P z$gsR1W%&QDEnecHj?_P?*&s`nnhi3=ayH16$=L>FGvUr%%u6Xq%}c~w?933D3Z@0k z5Q1jF=?nm*PscPa2$~@T&4AOn0i<)A8Z<))ngOSC14!rgM$il)Xa<}%14x@q37R1U z&4ANp0BN%wK{JG)8F1PRAZ>Pj&K5X zFbv5x7>48;3`6IO4MPlxnu$dpl34U%V0vmp2OW@fdqudQfkl^edl-lpgQzLDw-wel zhhy{s5Q~B*U@*NMgZ8)v>jcqQ(HYfnETIWUxBt2fQxtv<(>sWtL$&a8Xm9{O*BSCY zn4e4QoAz^Qebas}t)HlTO3;_3^iBCWrE9{^DP0qOE~Vpm1gr_)oz^$)=afF+=THXo zD1O1>5&r6e^m73*EFPN@!{V_iF)SXN62szAh|$l9VvwJcVd<-6So%2`mVQo#rJs{w z>E~ql|E?`gP@<01KPf+#CBr#p|EO|q%#13hACxISmx9zpMJzoJf%H5G%Fm@BXr}xe zDdn_?p!{44f@aFkkusf|@^h#O`Z?lsb(Eh&jq-CT2F&Q19_ z)F?lff?#gS&yg~noAPt03HmwWbZ*Mep(fkU1!QF@pB9iQKNpZGKZi2q=TZE|#c{Tzm*pTm&!a~P6-4nxw-6jQcOnx5K!(D58LozrO|o{T2$tJ*<4c;3-;dZJh& zG93fLwD3=`zzIC~6D%jeXB_@~gjF<5hqM0*t599kQ;%N{I&oqP%g$LLAdp7pS9XBsvHe zvgE1D{4g9Hb6njO2hzA}j}w6jZ`{n>7Nf&1oH!Q8(B75DGXw9vb%Jz%>sh>1FX36e z)V(zB(-@*$9M5CXu9n=x@j<5x9iGUND!d2Ads!~!qSs-CBbB}Nauo3RG|WK}oOtqJ zBuSn4lo2vTA{Hz%Z^UkGD`UgJ67j|H!t|>pG(xerafF_Vy_|Nq?XIqwf9QS#*v+2cK0~N4TEuhj8k8>M5_G_~RhMKTai24h!l7 ze{H5>CS)j;smtgYj4AR+Uq>)no4Sr<)Pr9~PeXG5?sfF+KeM$Mj8O&~MsOXKSR9%a zUU7soohEA*DjrVPmM;&Ph8=NjKxwMA^qPeD?Ysw2O*L2fYSgwh0lIEHYTx4+O zx650(hM0%M!9Ezo*dOU3Eh#lvMZ>~iMd^Oy6I&6-=P+!|%AxQX?*J$B<@i)sg=!of zuRt0Z4fHFsV_xVxz5efR%RN{ z%ZOZsG)R>R>QJ2-eSSvt1xSG^T$UO6@=RQan5y6v2&#}*A_Wp!gq%^1tFmG&MozcE z5=52U(yYi=XGUI@iOVx=;rvA)B{;Dd%w{EGpq#6aQ&qY)!}7WeT8)%0?)4eUHJQpA zGL$!FDu0)WYcp{jVxW9CA**J&IWzJtS&?teRIks(+YnV!8?tO~&y2h=Bk~=Y%1xPg zCt|7%Q}evIEbq!lWpgmz-9f-Qb72V zDljORIImtLeOcPiV1$gb?BH7rT%*eK>+yDws9L7MTO&3t{R%;zUWlr|wkhhJnzW;`T|f=rq7!f*bP#ga=FOYu=Zn`hMYsip3#y;Sj0>utkzdbJ8I8bm z;%YcAC2#1&ZCBOlfO@uYI11rjODHRm;_x>Mtf~i9CcXD-R*d%0tMq@({AD zJl<>~4tn|dCpOv1FWu+%%S?LK`R(j$x&q`0o zveFZ>tn`E|D?M>ZXQd}(S?LK`R(e8~m7chKv(gi?tn`E|D?K60N>5y>S?LK`R(e8~ zm7b7^^wO8ANGgpYl{AV3(wJ2iaUEurMaZ(sB4k-*5wfiG#5I?do{(jwCuCXa37JR_ z){tUJfv-Q{b*m<^_}g&l%}C=e!0F&)n;yWPUsxu)}RG{K?ET(3YqRz5|)6d*HnW6oFg7uhA86z^8bxAs`*oq;zbP z(y}I{L9XEQ}O z^fCfa>fCfaK`Eigg(S|1nTMZTUsUGYmlmc zdmMn<7c+2bh@~I>W5VLmKL+G`4H%MV4KO6n8emACHNcQOYk(nn)&N8DtO17PSpy8I z_Zraq;!~+I_@ipmiwZhu;Kbkyj)lXyaQylez8HH>el4J{`9)uY=Z5AZ&pifRaDZVo z1fF|_UMUoni1D$ILlyKw&~+o~LJh7Pf}CDMw;vGIgIGME4o#r0>qKB#E_Kp(XWAL@FHm^~j6`e>nDFpx zbj29>%$AO6QaZLtX<3ufaZ-vGK4!x&o-Y4{0D*L$1k!gCNZ(B$=XL>Lk5`QhOW!TS z(s#?S^xZNneYXhz|B-pRu>X3&{~K-5cZ#EZd-=&URKU_=zmcrN-Nwh(hPCf979SZ{V$57|HY8>zZjDK7emtjVo3U5 z3`zfsA?1J3hvM_#cR<+G>2$n99uINk9Wpcy_}Mg{jSP3lLSBg!{|h8kbq<6AcgTpk zP=lMrxaekupUs7DUHI8QgWbW-m#6iRJ$S|g+fVo>`iV*(JYSwlzp3-(N;e5jGvBdN zx*Vwsz9*H^9q4>{T7RA@Q}8`1rKj`dNf;#9Q844-*J#mUQ)g7{0w~H-jyafe?7@^} z2UCvAP@=aHg{0HxGAv!J3`-X)!_vjduyoHdEWMlz|KGJmKZJFJ&ciQqR~ZtVU9zJ| zcNL5#Jqb$Gsq+-1rYB-~>YPBH14mG&&QlOHQ>V^JDLov5I(43cpqV;#PRev{>eM-E zf~U@j)74R@&QYUIou?p}n>uw)%5)*ssdLl>Pn{E|b5p0zQKL?sry!V{I(1IUbZ+X@ zIckEZ&WY2xsZ-~u$-Yet$dsE3$dsE3$Y2(Qb38Ppl$*i`K{rL5E(R#mrB|oUF54EUT@i-lv2zTi?>&)($HRa+ zb`BFi6kd-HgukC0{}LOZsJ-~(dH51>QG0L+_-}#q4H;({VBQX%WdIKWZY)a(ZbA4m zp{zuTp9mRMoeQBR&N84_m(l(JMbRtKF5@gib0|zd;oJISfpKeG+(_18$w7zvzz2%6 z=QqUp>NmvsTE&rnPjdhA#P?zp^l8nSEN}dqf1>|Z>JMC(?^GEM9Ov&U4i`V%vwu0^ zFho5@nhS#u2LMc?VjLU;LNORBP5|kC>a7P?KX-67_Uu6t#|NDOHLm_uSA$2)Q)8Ose%*5drAoi2Uo9>Ln|GlLC7c2O` znAHEMt#BV9-7?VXc$*p&U`u61(z69d(afL~OnWK?u*TU?ai$IvKd|Y+k_Er7$MIBy zoKo@DROF!^^{O1jlLMWc$BmuJu{BzRjv=rZ3{kkOME0Zy#T2QKrX)sGod+I>PwN~T)Bu|J~vBSnQ1&PBXSiIyd^+61>RPWlJfZ((H9^E3U(QC zx`vl$;zGn!ovuJog}f3ekkBIJjB=#jR!FtMVvLc_YDq?NOS6)@Ix}+WZ3U{+@(kM* z8FWpiob&VGL<)EC~wSE{w@>OX5u=;K>2P$R;_$< zX5?G4BHx;+UZ07#A*!S{WZB-H8F^zy8Cs7k%9AiBEzzMyJL5bn=N;(-i$FoPaKT1#&$z@K$!fMQqSl!SX^YHF&&sS0|6 z-eLG2B4xb8K!U(K3?vy`eLh%bysdy|E%IR9-WBdMm{1?=U4?%@R!zOD@Ds@Y`MU~m zOGNLr!Tk9D=^JhEmV)RM`IZ9K9^Xdf;i zFh)!0@SkHK8#RJ8s};ZD$2y)g>XZ{f*9jPZ{=MUX8Rghk_)mx59Xa!m4X%sulXe8& z++glq;J>!;AC!u5=>DM)0d8-^-z0-5c;6`Q4Tr!tJiWwsS%sYm-;k3lYhbZ=&6V(@ z*vDJ=+14Bwj~#@O5t#`&9zpZ7ydi)}S9{wyJBCA7^flLJ2Nk4BMf`2Aia$47FZ#gU-lfI@H) zU8d!*twI-rx7IaCq27T0f!=D*7JzO%kV>i0mB3%+$5eKM zt_S>L$WbDPiyTQqh3+Njr5I|M zaQ(^J%N$h$-rwJO&wg>{Z0WpWNS9Hu_0Mua= zJB<}_q(4BZN3qk{ae@ZGFdPN{+a_ocwAm>5#jxQ9#_S3se-sO3UE9X@Bd|P}TW}FFwf4+~Bci1raJWLw~7CS+!u{*`*Xc1>yWH@M}BK$5# zE16DzA-P_paHrl6M*d3pgx{izo@wT?SM4%0pM4!Z2R`RSCV}Mi+~M$<5T6~z=eG_@ zw!8Rwy^WuD!)HFbA~MyqtV^|1%`+BEip+%1B_4j>6~)h}ITK=*d1vxmHcfo$AjyZm zO@jQ>(8ciiV=ii+KJ7(0{052#yMek`HJ{<)+*yWd)7wuds$Hrhii@bf}zwjonM`4Z4#?NGji zYW?rXn@%4~*gjC^(+Xi&vqesWwg>8RrKFY}!q-4;o>25V(`4Hf-3q<)fg%fLianCp z+tE8shqY|a;NK#~WA~dOHcygMld~RXj@3jj=4e3ci57y+XO9tG4?3T1l>}vZ7=ADM zJ<`3x4})K^s3+RNbATFE%qPqomfu0-4t8737%P$FJdwMH=dpf7KSL^c>`bCB1(g%c z)h_|vRYa2ot(U|$YQHn{SUpkHd)aKpN;=Bg{zHG=Y|fIBAa@Hq(`rF$*p&^etj z<{H*5x(luWzjKN{F$-8nL95tHp%L)wXZ?w;b&&pg7{*-1TI+kvL)ackE#u)4@Ee3J zVM&9!NbEba9UIaOX$@PF`=eRN?jnNUi-ghiGm++Vs{^|Sr(%ey`6FPKeq51jb!4v* zP0bwvzYx`{hm5&Skof61tb;QTbR&C8-44&SIsK%*OYUy6w3U z>rmGHNJ;NO9S&#sW5ZAfQKQ4z96^hmBfa&YTS?T{(|~RwDv7NJZ}Kovub2k(j3id< z74c%WOVBDd&}(j$u#cop^hy`DN6;G9n!8pP=EET#Y>9##*Xqhjh}r{nW8;ZhFxTqN zRufeK^&Dmug(!M-7C3`~=1jFJfZifH$GRI<5%mo9S-E`}o5VH}`H`>nNo*I<7=1mgMZOiZ z#%b^tT9cVQP}I+<0Xm-@LR1@DXia5D5S4;%Iy;3Z5nX6qz|J9R@RnKSY#LDw&}?=Q zQEhCQRlybzm4fafb~RBVy3D$Sts$z5U1wd&HW2Lts$>rm)w|bORqSaZ?pKS56~XDv^Xqu@)R6|BFYMQmJXw|)&fOVKC#N;Zeck9?u8Vygwc$Z$+t%N`)Y zF>xJxjbaYf|E^!hJ|`WHrR$h+GUm4kM%Is@D^%2|uV%+8;{19xMi7pyE!GXJoTvuq zckD`{+SnFr9a~3K3c8!wgG7nw7VB2_5>bQqsC65Ai>LibZR}C&4)!%sDd_HG z4Md6Pqt<5ToFeLjM5Um6kR^x`(PymRvlEFLyceuT z*y%(yK##JsiE3jnSdX*mM5Um6lFcDXL|?F;W>*q5c&}N{vQ+*a)yCej-e&EIN<*$t z^mA)3dyuHX+iQKxo+7FN`a64xs5Z9O`kw6|Dh1s>_C8S}y4U&#`<$r3`@w2p^+Yv5 zzc6;HY^B=R57w{DCn^Pb+iHLiqou}Qc?0mbq_NcP+?H1Zg%Fef2X>Tbz z-)^mar0nwSL$tlhF3)bKi9d%1x!1dSc6%*?8! z)w>1u;o2Z&S6~-wBa~fxyNfnn*|oR3X|t4Fd%K5LrR>_+uJ@x>p;Z4-u9_lH=?>&Uwf!_g0kytmuhD!yT116+H_^t*B+tGS9SyKQQFnY zZlHapwpQ5ZUtFP`NQA!l zLT!d1>5DJY7AyKhzgXKygueI^?Kwfx7thh&BSK$%srDnqL|=TV*6cLQU9Rgc)w&Ck zzW7pYh@wV)t~Nyx=at%(g3uSQv8%LoL^VM3wFil6V{7cow3moVLAOwQpC}PsV_&KL zov6XP)xJuD?J)Sa2G)wV+Do)BQElv2`)aL#s1$U|wZn)K(Od0nv|dCF-X?pM)}N>b z=sIl(QEhCKeZ4lCs1$TJXp@K%(M|U6v{^(A-hK8u4gV~QEX#fN&Dv6;+Sq;et=bJl zr4aKrZ6i@4dY^r}_8?J%_pp73_B2rq(4E>VM76Pp?akVsiAq6tkMpY|0| zgZHF;zxEHJ8lVR?xDgR0tBpNr|6a=_Dh1sm+95=V=#%!N+TlbE-d6i@?MR{;peMEC ziE3k8?WeV&M5Um6RvSZ*Jcyd0KK495!J?Cv0u`b5S4=N743SW zMD!K=RqZyS25-ClN9{hM8lXREj}z6#w%c!LFA$Z2?oI6tqC|AN{b%icq6Y76`)%!W zq8gyTXn!ZFjlFHZt2Gjpg6@3{ZURM{C8BTJyR~LS4c-U#M_M6K4bWe;5~AAJ2ll60 zf~XX9f74DRN<=@fztB!2s*8PU*J%@p_5ppRT|&gYPwlZqWX!?CR}bw7)C6diz(6jg+IZSUs#Jv{I;d&>cx>#GMSnol!52%ZNys~TSbkm0^yS7dby-eA4 zc8<`?m0f4&NPVHQ>+Bq*-=OR|J4fsHD7!AsG5Vv*u8Y%Ge^J?War)^ylwB9+c>M!q z*ULFUuTyrtoPm0Svg_rXq&sJ%`n{KPir$>4K6;FEs(uI&%Q@Z|q8BUO$<9!{m(mS$ zhUv#C8tIhkCo3B3oTd*~G~PK~KTFYh&T#!aMKhcc`Yc6BXQVz?(Hv)#eubiH=L~&? zAnA+G)Yl4f~1ct z)9)q1`_wZ16C(7DXX(EPLa%m(bC%w0v~15BptJR2qT1LM&Uk$QQ7Pyq>SKr!(JP!u z`YfUbZ@F`xK98sdXo|j=s5Z9TnWnEMDh1sPeLYbky4;zm-%C^%TkXu!A1B%el+<4# zs&`jA7wS8SxVPH5SpTcCTj$Kt_bIz|&Rjh*CN)CVIrH=mMD^}Er&{lwqUi0;0{u8e zo1M$_lLg6Mxm-V!2zzCrK26XfXM?pKXg1L@L30GHV#PW4I}7zkiEyQJg}z;oTgFL3VFPa%T+0%wapiU{@# zoCov?M6h4rJfvSh1p5Wf!}_H}uwUTR=vNZKeu49tzKRI;3!EqPn~7k*zBjR48^Nn6eR2MVd@ANK2aNqCN>wT4- z>HeS(R(7WQqkg8c^WC5HNy^T5f7UNlcD~!FU#9GQm+=+KF3;8ZI%SvV8vGt*m*-mi zF=dzMI{XD?SKxYlhq5bheg3hsD{v!xud*v}bNJ87uDu)MIp?JMy}jFvcOt5H+q?NZ zLBzfGZc9Fds4jN6TfoOCyTjc!e5$fL+-=J*R(6NGg?yp1>+W{oE0tY$w-aBl?7F*$ z^81uscQ?+TNa>>YJ4Jje5z9HsE#|K&U0=6^?^L=I+%Eh>r8~v#%D+^)QnwqgS2W7) z&Knh#xjncuUbY0wnc(*1F-7OQNAN;LGu>YNa77ooNAe>CNnhNX_Y)*%{oZ^S5zhKY z@d<+DtbY`rLWHyaQM_En6n^?BzFv^LzfJJRq)zNLC-{d%IO`wHoe2#7$yvV-k1OiT zkKrd1;jDiwpCU-k`hEFgBAoS);~Oa^&icpk=SYXM{&D<0(&4Os9RFESqu!6VnJ9BF zw>j_6`v}5Wf37=#pH5T*bRwTZR2!S?4&w8PN1W2@Xr{1l>6(4EIe5hbFl+$nqlQG<7* zJB?pJR0A}FUrJOPyV0G=uOuo3-7LO}C=tEUP4b(G;J)9zkZ&e}`+oOg{s}lWA60fwxodf?vU|$CiNB%jo_BBIA1J%$-SzxyW%sy_Ou_bGm#vfJ%G!=F%gyWQvbHf6Wl-OArqcDvnL z{)w{t%zcsnsO&y-U*`UKvhMZnXYMv$NW{I*+}C(7qPp1E?(6(`qJ2Qy`RU5;Yj+1f zTiJc>zQw02yYJnde2%jF-rdC)E4%OAclhq;`8SG6ywCVgih6o~%9K%`9>i8#u*05IgFt3j1Op*DuvPXJ*_z6Ta{Br9neww1GK=_gX zmaGhPd-*&fd;-3gKSoq4sGg`>xINp;hfF0qcy9kKpC@P$yEJyWUeA{alAffV-$jI; zX_$V;+e)?qGQ}W+%kS5!d9{jdpg!=5qruQ3%X{4;*Acts06+qgi{QqM6e6|M3-V<{2#blA92(Nv&EiLj@mMlBKcbkq<>iD49A zPe+YoXJE-zG3@E6@qi%gqqSbH@eI*EpgiL>qWWl+*W7qZ(QRJ7@tz>r@-2){1<96g zVSFn{wtNf2xB&CRHBk<0VYCz^$8}4ivmn{>EsYY=VavBP`bdHw`nl6Z)-fA(m4aQ z4#umB7V(b8JBpU`&c>HS&BE97xUr82*HUrAn2B{?#NM&ig07jO4ZPUssAx0qVjQ7p z4)1Opujm2Z!#G{hqr8_fUeVLMw=q-ER(_PRK+&uG7~>kEw_6O3}d9CSK-fEo~!6-KGv8`v>j?xX3ST#o1bN@Q1muG+qi}3 z1(;hW822dJ$0rz%6a6*X$R`>vDdNVt#!jL-&`mZzQN)e&jK34rSdDy&q0N%Dt+8BV zs*yv~Q;!R*`EgG~Oh-G&a(>()d`><@!~|UZTJG zhq0@SpB0rER~g=HS@%IXhq1**3qf*rTWoY99o{i4HhL1h1*t4C`Y9?imKZ~cj)YW} z8e@s3yGZ9NnqVw7E+Wd)Cm2^73yHkk3C1#Gl_c;1Ic&MHK~X<_h4GN0jqDoZc}0`? zD&x5aw|BAh>OG~N@0cRde#YmL2% zp7L%oej%!hJ@4IOgeoviJVWrjx87()R3F{uZ7|v^+V0(M94<)CrW=hT1ucSA!XCcS z7(g+*Ls>Q&rx5iQbebT1O1jhAXp9%M3ho=<_3kj{5Pb=>$yg}}?;FoI?lkUIv|GQ+ zc$vtL%rG_^p9qq3>)i&s5bN+F!@2byqm7_N4ClIgj0EY>_upfTBpr@|dyH9v(93-2 z-D}Jv+6T17xLWD{<~?BCtaN|#9x@&xs*mpV9yXp(^u70pu~iUynFg=M*d_??u90>U zEfe%H(M1O8z970l&^JU&La6&u5Vjx-)fgvVgtf&Mv_g*>X9~KEeVNnXJz>ldge`cH z@r1Ej(Qf@o;{hT+QfWM8ye3Gt;M2zEMA(AQ7{ubR?(08v&Lva z@)~>2xKQahf6iDX2*+SI*xF;OB~ z6#CrgN7Uf;41H;gAgTe{W1LS^8|xYR+NdNd1>HBsHAIPM&(L?q?L-Y;pHRK=C{Yd2 z55}uRwXr^-AC28arJ(!C_&ZS|+9&k0VPBeR-2tISqcu^DHz35!ZbY@Q0U_Nyfv6O8 zhIuAYB03;snbV0Hyul&IoKI8(-r#;EfHnF$WOU0JSwwC#sE&4HcT> ziAq7&!Nga6ahxThV?&+HYN7`3+|Z%swL~>QadQ(7nlC4@5OUJx#At=2sh=9_nSbB`O77Z?h*+B04>kFb5IU#VSI5%rc^VK*yT1 zh`3h~I?lY3sNSsz^*7flyUNf2bBnU844r6hRWU0=gUp>o+^Yc__rR))?tUsQH0L*vbNl-&)XiRRbJ?uO7LQ?E*u^M=rQWVA{vb#4l*Ze@)-5Z)`ey8m2g}0roYFTRT-5Xk977*3NejmErJe+7B&=qEasNVg3 zXpwo6vip5#v3Z8Fdor}toTlua3@tOOmEDt}73Q_d?#a+fbCa^$8oJheLfLH%tu|j* zc3VSh%#W4b*3gaS4=G*rmC#zVQPK9$I@6vnYs7Ni4&7wtD|$b4v)NhEUqiQ;M=1It zbgOy1qP?N@W~rj@L${gZ6g7l4n9~(${_Wle3%GNhix*SCBoBTo6K!Qcsgv8`DY?L9k$8*kO)tQZ8GZw$I z?%87QAsw!JwwTUk4E`+=XS27MofI|d_nZ9{asGfgPLS}o{zGO35%^pGVRH!)_*=im zyp;(2t^b($2od;O{|WO|q6V*{|CG6ls0Qd6^HZYQSV#Xk^E;wa&}}t;B}zm)`n9Hi zIhGpBQslpAwj=_7>%VMvA_9NwZ!^0Sfxq=%Gmj+#f9t<)o=nu>_3*cwqljvNc9;{1 zYGXb8x6E>)Qqb)*=Mg2MJ^Wqf5~2n#;lE>EPgDc+o_QNlZ7kt`VBSYm3c3%?$B7cr zg#WSm0#Sq4&;P`HgQy1RGxL3-+E_pTbMp(LQqX;AeovH$_Vf3c+QL-34D!D=!$dXS zApaY)6;W+$kpG?8nWz+W^=1#EM0AkKvW94 zM)LxqM0BXntV@X+ypg_cT}e~}WLT?+YGWgP%etAU6m*WYnJ5t*>3h~AL=9e|%Y`@65 zR>hp{mssnGxHsGHYHd+=bNueslge(6-_v?k+0F5LS-X_o9KW~qsj{2zC#=6KyZL?} z%eYe3w%(oZA8W;kxHsQF&MG9Ti!Ji|TV06u0S&PFD!WDgiPm6cx5yu4ovG}W`zKqI zl-+WFuyvubTka3BE>m{P{bAM$Ww+Wt&044IR{O)Pdz9U3f28%8vRmz+VZEU2*7>8Y z9m;Nvi2&wb^h7b&&qCtKi+Z|$(Gm`+u%>MS`pQ|8~jPup+wx<;Gbt5 zK~xvp>`$>yQg)mDX;zuC+w9M<%9Y(_f2Ori**)mbvaV5f5Bf>#7G?LKf1!1^vU||K z*s4)>kNI<~=at=K{#@%#W%rmr&-zf=J?2+iU!`=>XZ;1%_e3n`1^+UOUq$^Mea*kz z@`+f^4u7GQuV|Nlg;l8N1OG~^NYN+$BCD68Fa4{m;}m`4FSbrr^n<^|8m{PPf2nnr zB0YSyb)F#UZX#->$aqA|3kM)mAO(aGznd^`W9h{d((XMVzm(S}l=1*5HN1H(K3@YJk>S z1Bq&5;qXmX8BrD2JevYz1CYqH9%Xe4~c4HhlC%n_7IhV?jh?(qD1tN@WYm|G*zQc;TkKK zsK)CQe#~l1R2%CQe!?myDh1tBR)Q!I?G%2-8c5XO6^Ea*PA94X+G>p>s*M$gYptn7 zrJ#G!x`-$dEe^kIT}A}=+Tm^1aw53b4!>sojtK6x!>?O+5W&56c)Rr=5!`EscUVso zHF!sd-?CmIssY+*{h6pXc64}`^$}4i=-#ouB1%M$4!>vpgQ&slAO65Hua>P;1N5Pl zOH>={AO6@ngs2pBpICnft!*s$;q*0n^Xp!?CfnJ5t*7XHb)i>NL(D*Utc z1kpaAM(a;R+#3~U_D4kZ?x?VC|6SRQ3mdk!Ot!?n*toD|$B63Pabd?UB;ww&rD%5G9PW=~dj)5Fc|3S~DvoNr&D?52lX+Se+(>EQx< zy|PP&+t~LhyJWbn{j{=6h70X&$}So1V85;GE)93GKT&pAx)?e&Vb zg(ui|E7~5OXg{oIXZT$E8Ab1fC)qD6`Zzq<-l6F8@Ok!oioOn?Z+|98ddeyGcY@GU z-p!`izY3D)v!>YAHQ0iS96X;j#SROScbHS`lLbkSH`OkcI^pqV*i)pPc>8yTy;xCa zet~@#5uV7JX}>H;`oD7fb0YM3vutCf$X)EL&$0^z$-UoM_OYZxk2lLcOHrdf+n%S0 z^Q6625Z=|*hcC1rC8`0s*nW$sHdY^=V}DCj3c9&=WR)B}iD-Rzo?T4T;QbP=wvQsJ z0a{?6KvWz1C49MEN>mEEE9^3&MD&;NBKv%z2G58rwkwEgfR@_xiE3j;WSM<6Q7PzF z*f$U*qDEw;eLGQu7m8eK-%nHnwAy}>s5Tagtg&ArDh1t*_M1eBXehGQ-c8it#UeM^ zbwo8lx7hoLYGbj;dYfM>TcQ+n8|)}iA{vWqv|AH3c&#Fv?8As^fbO!7AgYbEirj7Y zBPs>mz4oa@iD;|H7W+)1x>#Z40edRZKA?x}Y9j6xMjp0T64kqfks5o0vWrI^v+q}S z@yHYQvnpmh@|67=5%=PeXY9WyyKa%^?9Y^4x5!re2W8hSQfu?;WZk*fE%KtBLsS>* z9eLS4glHeoHoFTEyoVWi&F-V@dPiQjPf~V$Birqf%C2u@hdoKz^^Lq`&sKJQBRlPC zWp`p^mwmOeJ2CQ(y-wMk7-tfrRc1NPR*qF#Sc6XwEK;PN@mED*~ zy**UfjfwnVk5zW#BR|?RmEHKrPxj@?ZhYitdyTRiA8EAjR(4Y&%z0GVO^N8vOUiCa z#BknHc2gpj^O3SEk2ucP%C0=(IgQG$JmNc{>r?$+9*H4b#j{GBTM7Gm|zE(E8xfqa5*xaD0J^qFx0b zphppv3JNI5MYzYKR}t<{k0=~H+>6}a3+Mm;*4ld}ZQ$_GdpVk!U%s`zZ>{yM@B7xb zzP0w=Yftu>n)1YNo}T?d>TaI+wdnbRnJ0d&x>GQ7@32*mgqT}*gnpOB8WXX)HhrUD zCbG}h4_J(m{Yd?!t;uVdBlYa7*q@2)N9q#=GxrXU)Z0Sr8TTlCQHXio(fXr;F|yy5 zI9A_kv73P%r+;R#ed*g0C+Pha>qXfj{i+YKKR$c8EwMzOVzK@8-%l*l-4?qU*ok_( z#rCDYpEyb9EY^#%m3q=*E0f<(oT~R)Y=8Z|iBV4@46KCj@#d=ZJquVUDGWlR)lU{DI z{q;XjY}TC?yBXNo`W%bxOaDC4uZJwwi?S_xx5ZW_f1cQ;FSpqK`bQJ5(^p&UW?(z? zXDzlb{b=G1`WqJOMcH}!9*eC^KAPC6e{Qk;^^Ya8`f-ch3~We0Yq5Rl#}XsD`5L2N zFUsDikFeOvu!Imv7EPs4U|k{{N;3){^}epEjbwwssyxNiQi z(c!7|yySKID2qKApO^fkKG|Yk{k-J$y4zxprROI61JP4 z{DQtRYAS<4$0fg_e{HcRG(ObP=>3JdcUGEXS zD8%meeyvZl7*GEFi#{{N9`b&x&keC(c)!YGFC2JdNoM~GeL{U8045S#Fx(T{}Kjo!2R-$Lvb&y8c)WNaUd-t9%= zsSvx>i^dPP7*GDi;tNCU7oLu<3bBX0`go7Uc=E3)zCFaA@|xnq7URjkM0`BNyht+s z4vX>RUn>6I5c4AG__Y?}$-mk0FNRn=GAI5mi}B>&q46Jv*qq4R_|GiHlYg&{|1QLi zj=U!Rze8+cT7}Q0YIgIA$Pw|mA=Vx_GJb4`oe?=YezL`Q^6%JqSBPEVEr_2J zVwZX+#IqLT$-hPMQi#PPi{o##7*GB!jb9mJZ*!N&KVmVS{97LXY>1s3SswqI#dz}X z#Q66FGy9hl$~_(T=IOdfxT}= zE4)2kL%&v&a$6H?<^Ub_U!?czYTz>A|J52wwbWG)r<$8R^)sncEAw?i`M<*R5t01= zFKiKueY~L=zn1!#OHJn^@2Wdv%%3k3_F)w83$-#9x7X0W58VSx8Vf%p9KMud{c~Yk z2XruTDUT_wwPbDn0vWIU!g+&m zezExjD7h# z`B(BN*IMu3HRWK+UwV~!CEIF7wwFI!XKeV&v0?4p=eYc5-kr|))hoxZX2#;Ldo2DE zapMbehx|<36%X#Lejax|UG;6b2Yc{6TeA;&Lhg~Sl6#~tByS`?TJ9JdXehiJJl&n) z+B!zUABj{K%Ux);b=8R6N!}v&d!I}G=aQ{fo?1yvzeYzxH!v@no{1h^buny(rxnOY zR8<~xKh{KOE1?JLmhK$&Z$4SF$h{)_k( zp{si3F89F{V+W(7>HY0ujjP2n>(R=!PbKzCo^?F6LuLmlSffLFZN9dSTT?&C8~=GO ze=t_9mCg9Gk<;Xj|CoFACjUv1suoszan$qA6eG#eu>+r{)Xw^QWUiT~HiQ_*=bh=M z_u4soidf7*Q(AldV)8HT>4V{Bc1#^W`4a?Xr4&UJO?!PoOurT*Z3UpFY)Xz zuK0gfQ-D!57qDI}0BlxE1)d_XLtwYSvjlDz_#MEgdRX!)=agA!$p9xhCM3f4PC2ui&v536gmaz8BioUuB=c0c z`Qw0F<8MH#o4l-ZEo6?WAE>=v$=Qqg{|#_|{lm`J)i2y*M4mSH2$Sn zuXS%ydGE98CiUyo=aA>Pbc_AF9llLY_$VNMH<<8oK)!+A?eI--*8G#eX9RlQUW`;d z;8Oyh#D8zxi*c;?GR_HZ+M6pp36DaazZ6CIxI0&P&J~^<{Xc=i{}Vvyc^Snz8Tr2q zDd(~DSzgL{N?^yVt;qBLjO~0P+p?ZUgu!H0ulRV$tPC5KvEh&d@Y7@=@ z070W=O2WH>y+4M2y_{26f8eyV8W`BF}fDQ!+-dfY2Wh zI^T9qIeg2RFoT+Wt2yQHZRVVFVr;9Ib2-@Mq~| zubPZp5ZSBVEbxj3=J%x^#vJLz9NDXG7Rdipu~&YVY%jd!LgdMFulUSf`K7VFm?O`C zLhmBPe{2Dy$F5A0&y&fwqSceh%LHB_@O=WW7WgrNpAz^vK>Yrjz*_{~D)4rJKM;7Y zz@G^GXMqn3{B>k0bpO4;U${#}cfvn{!kM*HEU;88K=>!rq2z>^3z$bwMHYzl2;I5` zXd4swxVu0&ED#P0gahH9Kqm)6&(rE6HK$IiJ?d3}?@)&WUapR;a}m`R)Fsp$=Xk&t zK&>Vn*1XtR2e>`W{Oi-qJ4Z2JchtJNMc98es2?Sn&QcFa`fByRB%QCGmGpSEqM7B( z)kaBQi}$UGuT{RJXWH^Uq_^WO;z2dm{D@6&_Y9uJ`J{6pap&LL6u)FfJZsZ;*mU1~ zynPJ%KD=Vi^ii8ejxqSF)bVPudM*0iir*u+U;Re?LH$X&P8_lLI49@4$$5)&iSth9 zJL+r7_y&^^?f=PmY@dn>)w-g@s1-l+FX#Km6K!zq*qzIFJ z)r=J;rCzPlSQ}=k!_^$srVdd@szcSW>M(Tz*4V}BRcZxltU`^oszt3+uTkBwH=1&7&EwC^0Ipn{UB3()TagUTYyI%y%3GAq6{WWRA8=_wcVP^yL*9+xJf#VJ- z@mYkg5oqea@S3Ln^-=b9rNHSZl(1JDd8+x2SziPF-1s*EZ-_n@otmB)W6e&1H$=aK z{PhB_6gU|n<;?=GXkh-uXmJNQHxOPQCA?DLxWjyW7U63IPN$cVR=x>2l-|29|tqn@FNE^;MK@q4qtK+4G#zWJ9Px$JJo!^cd4TQuTaMTrkn++-wcR;o#O## zIST=2JBtD5I7Z}0#2j^tezXs4%Uvo}D{uV%-zj9s+_>azMfJeEjK|c}@ zzX;)W03PG61^j^91^Nd8U3Hba9`FlpHz;2O#Cb*cOu(DmjeuWrdjWsoo`ur809|#r z+Xr}$dk)|a-K~JfdD{Vx_s#`8!FxU6>D~a~YA*xW?hOKVcs}47Zy0c`hkd5H%R3+N zZf_Lu9A9-cKd%bbM`@G$NXGbOh`yv+t_D3!TJSXxNz%7xt0&b1G9dKLZ z62PBCE(3fpvKR27$U6bs>#hLosCzfyn!5J@eyZ+$fY;Z30PxdwR{?&e?rN1)=c_&^ zvWM5YwV#FZ8x}5VnNMTg8*uiNCqip!^Ad*U)YLm^8rpS;wFkDn0Kd{8pRU4SX>zQR zD;D~T#e8{S$-we~C2DKW01CPbl__{#$Hb(c34OHe)cCWDNR?(|DrfSYRFWs_g; zS2kuQOuoOA8|^A&)!LCvVc0Kk_Dg;KU=f6~i{pg;SUxl8lk<2!-&@)`lB@WAV=x^3-{2u~hb1+Of+oWrlr`a*bc9_@!EES-J|X5mX+^mC98c1yuAG zWIJE`sFe^9Pmq}VkyATc0+OZ#__=sBLvhO#5k~GcVSoYe4ldwxm-C1 zpC@8G)J_eHZ1Q(^6$UMGcBYUmj!r=~iM_+h6P2KJyim!Fiaj=<6*{oCTURQMT1p=# z77D@vFO-Ww%dlmCt|B=z{syCsH)Tdm1)Jfh(YS)LLO2K^r8)va5<7=Y1}Z`0&>=UM zd`PgqR2(0Z24e@{yD}xA4-_bimHlj^tqgf@!3_PzTw%OSF=uv2=d5AgI4Cm-n~$r81;HxUjo0#A!;^GWqAM1*;6@hR2Nws!Tfl zp$v502(kQ9l}uf7dEt4spU+H4u3Rk-1lwFfd>X7&3t*+pXh*4p>2#3RWSS||6xgv9 zdL_3rm(NvdO6hbmK;pM1H(;ZrpEYij_=$Yc7i{b=aCitlC}0d;G#Mij1%pfqDB!{0+I` z5x+ErB+kt7H zLY1u6RSH%_h6Su7*g*JWOot`>B4eU2NgRBpp}DMj8~tn!kiS}TLlsvW?b_wmr@`Q0ND6UhI=`Lfj*zNlT(GC+;<}}ld8GwON0PyO}am_3i zg1~C08u(z*>K*DB8_VYgMLm^;(7A%i2SK^hhPPnGuFn^Da{FRxnOz^d!33(5GGZFF z8GFzQHYv0dgF<&ZC>6#eyWm~NL zFn6#ch$*_p%DFsxHd9+7p{zp6WPSW^=(WYMNhW4VVzdWImN@J>1?8lConI;nM55^K!b!#Hex&u zd3j@|fbCmJ^%u_>8#SmQn0y$TfTCGJ4}~tQ^#}%jP0nB4E(R`ux(a z+@OC@F+B*wjvcryH#-uT7#9_&K4|vn>YNG}-W(|5ZmDdi1y;mz?+`<7x#~Fv#mZqN z%?+MkRuTcrbj%7S^g*(8O;r2>XLeXpa}i>lzYmkU(kt_(j9JQ=1cr9MRh=0Socjow zB{fpjxS5fQ15;L5Cr3>V>T=Fw7gbfo20H6Bq4+RSXKpxGsU`Fl@{^Xxy+3va7PEW6 z(3Q^i%b2Owg8hh60Rh8Cl)4SbW!*T8L3asO225vAWM#J(N*xti6cJAu4^~6s$XvVD z@j}!tVkTd^gc(Zj&Nm`ng*G(Ws!&pkA25$_34;h|%QjsulnO;@Gz=*lF>MwS~H2x^AtT5#8 zb)<}RYjG(_3ZdY}k2^+%f-8&x3^=boEoA^BUxTuVj6+R>T700wL9&Gz!_>}LEIKk) zT(>!cgKKtKo@Jkc-DR2k6&SJXBRRmf<#n0z!9?!HrY#^5{GKn)@(zaVW&PliUMMy) z*UTCrSIPrzn-bj}9yW!TX zVU|Y8pEZu4&{@jt<`#y7FFoQefm!yEV(ITFWJwtqCAm0`OK914*RJe_AQm-Q>^%Jm z_z$46CBjVtW3OsRJ&UVcT(Tu`f3U5NX>7puicmm($K zZq#m7yK%=ik8dk@WN;smJzt3X!WSbQR3o5aqb7Z|qGkb9A2gPv;PiqERfe(b= zsn`I@rj{Ctp|XUz+8X3ki>pj4o=XLFTGfskjCC)9X4U$vX=(>KlNzo8m#Hm+9xf6c z7FZ4jV+(RPR>~+@z_*$s#e9RZsVy)Xu#u@{^j#ccl%H*Pg#3+uhDsRxP3>W7i>d~s z2R1SqOtt4!?E>D_ngOM1QPaZoP%CX9G5M2jQbJm{T1s83Wu~U-rAlQB<*0KykPgD1 zaa{sWE5YlqPKxL4guhkbu|B@^#0tES{#vnfhI7IAIp;(H_r;0R-_ODrV}axf!(!JW6QI`M?=uc`rV2o^bw_P+mq#O(;oC{WJRy zkh?0iX*q;8CCKTE21aYnHS*jEU4x#FQfljFP&o^!d!JYgcW{x%nhaQys6cBBudSamh6?$foZ^-qcM&?%vi9$fH(OTP^Ox?gmX7w1-7IFNRx)z zBeogFBeHyuOPP{&h)6}qhq?_z)%+||+KIApNS#M7swrEG%?WDI@;MpnJo?L`W({un z^npM9ixEyWF`9FR{NJP)4(`#Y4ZS;StjIe5xLf)~Xibuew+Ujz^cMh!C7CZI}>kNZD1@Id==r;J|WD zpIuVRxHTuOnLsAElp)regkpk3?eZ5a)pQ{pAq6oV%)Rb}fpcQ-!??G^V=v4B%Kw1_1j9== z`LjB}Mk61ch>B5px>{fkrpA3}-~-K9yZ&*lan9Ku8knXx9F4qF>rT%%dS?P#It)}p}u0(%9krP_1* zR#`~tZ)Tw@h~Ev1M+TE@IsvPj-swc3kCmWAuwd41uc@2~a2&Q^q6U5Kl0nV^n#GB= zryJy82w|Q*cLrl(f=F$6F&%Mw1s#|Ok(a5*Ns@!5ss3{-bl~2^jE&)Eyy!rosTfD% z`OOgQn7GEuICuBUU`+4pf&Wc67$yX>9j|6^bnwH4V>TMGk6DSF^fz3u-+-&+5L<)Sr%L?S8Myb-J2H&Z)bf z={1_VKMc4&AJ5wTh7ZhGhs|Tor`!7Tb$P)yveHF9t6H?R))3vLOKD<(){kb3GtWt}o8`bB&E>g#H zYtyABM909Uyw}3m&MUCsT5=U4&gn|k(f8EwVq8D}<-cnELTsa7{@3vqD|L7fk%RU5 zRC|4FV{J>vlivU?v^tK)Z7in_nN*5s zBBC5O5skSmiIzkiUie5PP$A*PP%-8tV#;+>D^e?vcfDw8MMEq`w7$NnsS)++J=|bu zj78?8@h%4F+KrlQ-JJAkj%GKr(5nIir8L+(TBl?6>`NySsjgI4OCr_nMwORH%$o;> zXyQ5^Wo*K!%v2ZNjzCcYlHpu?7tY$Hx-p=sJs)Acd50xqx+MW-!Vpm5(ya1 zP3Tq>d8s{@Ku?szhB^UdXDMc#1o*hZ2&YNYernIPk(jI9x|o|96WA$mgTNjah4qrH z0D6tEVa!YAS>J0i$cRZ+nq-wp+D+1>UENv-8PPy1mo`mxkwaFyu~;4cJud`@0VaY> ze~{T0WOgtUi8u%qRcK8&-JkA{#k>U5IK4#Vg1dp88|9Rl$6DLc+hVOAt)%N?G5CqpBTKkU#3803 zf}2QYYGNj6P6;Gr;(-b3p(1Gsl#nGGTgFULgvkYo z+$gk2?RhJb1QIY{3l!42;6jL@2K2o8R!`;-TpHDp1y_ayPn!}?qag`CTZI!ut8v4AUP{1 zCXjt0vI&e}Xwh#YfZG@)_f!{#vz|l(w_e}4df+XopVXgf&hI)1mv~zM0COBu_*LCl zWvlzn+I?!|nP>6CmQn3R(@P@JmUJUBc%LkN3K5}b=9;1WJdjxr`IbZ!p%F0==yo^S zR@Oc#5%}_N$;dzpJ2kdFO^a&SPNkv zmRw;1JX+)bd1J=H4;h_J@WrHs{m`uopFobj;82Rx$|hu+niwx+7K48ih)6(alKBWa zYJ$r8tE8&TYpJ>l?-!!Qs(O>eO+slwjF}{Ak~)(_Ou{ZurBS*7KcH?(xFI1oB;nqP5^_UAZb%}weV0Lv;H#`}trEEj8__^H4Fc;0#szADF@aHmbpj*k6((ut7o3|? z?MBabqi4I(v)$;~ZuD$7dbS%q+l`*>M$dMmr{M;^7^)ReuHKM3Cz-90~_en23i6MWk*6wAThFU0GYCHFuHFrx^FOJEbUQd##q_|V|ye) zd!zdXqx%Nx-hevXfe^+8vR6hP!l=MHff4pjE3u$SU?a4E5O(PNb8F-k~#lo=(YJust0*xo47W0dHT0qoI`sR1>q3SnHJ78ny46<8-Q zLUE}It2PO2O!Z(^H*z1wV4LnooB(X`Xh2{bMlO*k!%~T|77qyGZF(E4ZKC0LS!>^bW=&EZn35XGH@+iXgj|*$Oz?F#7u?( zjRZ3r(SeATHG`QogPAphnHA;1+f*^LF>3}hYn%amO`#dgtVA6la&)rLut{K}zy^W! z0^7#FAo#so$M)(MP21*kd3FT~ZU zF=~W_q98GmXN;l%GoqNPXk=6wGtN3@RFU>5Gpa~?U`Ca&eHYk)YE&6(gskXS0F2C#aQ-7f6G&0vR<%L$WJ%cxwZNFbsK7db5z0r|S*b~2BOqhi1lXo0 z(i1kAO|UaysApgzJ>eaTt<$ke<1Z08me2XAf$wQ8V0AfhzOZ_*a0d>~?+`=mDEO5@ z*fujZ28)Jut5p|`Wp}E+4IRr?oTRMWk33-Irfn`i|B}yL^08|k`q1mve*OXIAABBX zzBRz6roXJIhXXMf+pY;;&V7%TDU2^i;@Rfeqf~4A)W$Q|->?N-nNO{FV0IX+uo>x8 zV=$^HwQ?Fd>+KE4A7(;w5}gVoA7HO`5rTzYh0Bc^-h*^nAd`&yk9)`f(SU z_tVQLuil}T3hKtlI}oVwU(#`3H8{m`FsJjR&JsK;Fy9mLpb}9Kvd==>wdl>9y5f1C zP3VL7srfOIRUd4cCo4SN!KY{DX$0$S5n&Ch^%_Rg)Le?;luch+|3u^~*6El{4vHhEI;WLLKq#B1UaR@i$_QJ%WbPqZ>n#qUzM>hNw$JTp?q4~c&Tt| zd2qxZ&6F38<_1f}a&f4#5HA6onkkPi+O@Q;brfsg5Kij`y9MbF%vxJRX5CpVsW_TD zMJDbB+FJRx>1k~nCu`m=T7>nnZL#4{DUI`mz@g#`lxJC+v_s!`ZDSnopH5mFloE~& zLry=7w~lt<-3%O3e}P<=2V7h6sq(=>Iw*UA9)FjgZ_N{))|M%o*N{tXt>d|lLA)CR zGY;|1L#vc9Sv-w2f#{2;$i8ZEXarPPwKy0dJi7X`f5sgA_6a_C@IUkU+q1yG19-dW AFaQ7m From 796b3ac61ceb845135fb3023f727febda1b67a8a Mon Sep 17 00:00:00 2001 From: Josepe <72740829+JosepeDev@users.noreply.github.com> Date: Thu, 17 Dec 2020 03:56:24 +0200 Subject: [PATCH 08/53] Update README.md --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index bd6b79c..5b21844 100644 --- a/README.md +++ b/README.md @@ -99,9 +99,9 @@ After the benchmark is finished, the results will be printed. From there you can I ran a few benchmarks on my Laptop (Intel Core i7-8750h, GTX1060-MaxQ), and these are the results: | Comparison | CPS (Changes per second) | |---------------------------------------------------------|:------------------------:| -| **EncInt** - int (Similar to **EncLong**) | 14,617,745 - 525,762,355 | -| **EncDouble** - double (Similar to **EncFloat** and **EncDecimal**) | 20,719,376 - 329,739,613 | -| **EncString** - string | 373,450 - 13,579,435 | +| **EncInt** - int (Similar to **EncLong**) | 16,019,622 - 525,762,355 | +| **EncDouble** - double (Similar to **EncFloat** and **EncDecimal**) | 20,155,276 - 329,739,613 | +| **EncString** - string | 501,253 - 13,579,435 | This is the size of each EncType compared to its normal type | Types | Size in bytes | From 8d51c9d948bbd6d1573fb3fa720bf1d9b52a930e Mon Sep 17 00:00:00 2001 From: Josepe <72740829+JosepeDev@users.noreply.github.com> Date: Thu, 17 Dec 2020 04:47:42 +0200 Subject: [PATCH 09/53] Update README.md --- README.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/README.md b/README.md index 5b21844..d76d84c 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,10 @@ ![Imgur](https://i.imgur.com/jnXHECv.png) +

+ + + +

+ **Content** - [**EncTypes**](#enctypes) - [Which type to use?](#which-type-to-use) From 1429b0a88c2a1fdf44044ac6561b3e658f3f0442 Mon Sep 17 00:00:00 2001 From: Josepe <72740829+JosepeDev@users.noreply.github.com> Date: Thu, 17 Dec 2020 05:03:52 +0200 Subject: [PATCH 10/53] Update README.md --- README.md | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/README.md b/README.md index d76d84c..f278c55 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,21 @@ ![Imgur](https://i.imgur.com/jnXHECv.png)

+ + + +

+

+

+

+ + + +

+ **Content** - [**EncTypes**](#enctypes) From e485f79d6e1b43922a0da545499dfbf5bc2bae55 Mon Sep 17 00:00:00 2001 From: Josepe <72740829+JosepeDev@users.noreply.github.com> Date: Thu, 17 Dec 2020 05:04:12 +0200 Subject: [PATCH 11/53] Update README.md --- README.md | 1 - 1 file changed, 1 deletion(-) diff --git a/README.md b/README.md index f278c55..1798503 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,6 @@

-

From f7f6369f74c160ffc7612d92202802d21f65f4c9 Mon Sep 17 00:00:00 2001 From: Josepe <72740829+JosepeDev@users.noreply.github.com> Date: Thu, 17 Dec 2020 05:06:57 +0200 Subject: [PATCH 12/53] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 1798503..9213e33 100644 --- a/README.md +++ b/README.md @@ -126,7 +126,7 @@ This is the size of each EncType compared to its normal type | int - EncInt | 4 - 24 | | long - EncLong | 8 - 48 | | float - EncFloat | 4 - 24 | -| double - EncDouble | 8 - 24 | +| double - EncDouble | 8 - 48 | | decimal - EncDecimal | 16 - 48 | It may seem heavy but it's **very light** considering its **simple** and **efficient encryption**. From b962d301d8179fecbd42e3b9d02bf0405be15548 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Thu, 17 Dec 2020 08:03:45 +0200 Subject: [PATCH 13/53] Static Properties Made static some non-static properties that should have been STATIC. --- .../Variable-Encryption/Types/EncDecimal.cs | 10 +++++----- .../Variable-Encryption/Types/EncDouble.cs | 12 ++++++------ .../Variable-Encryption/Types/EncFloat.cs | 12 ++++++------ .../Variable-Encryption/Types/EncInt.cs | 4 ++-- .../Variable-Encryption/Types/EncLong.cs | 4 ++-- 5 files changed, 21 insertions(+), 21 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs index 1e3753b..55cd505 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs @@ -23,11 +23,11 @@ private decimal Value get => Decrypt(); } - public Decimal MaxValue { get => Decimal.MaxValue; } - public Decimal MinValue { get => Decimal.MinValue; } - public Decimal MinusOne { get => Decimal.MinusOne; } - public Decimal One { get => Decimal.One; } - public Decimal Zero { get => Decimal.Zero; } + public static Decimal MaxValue { get => Decimal.MaxValue; } + public static Decimal MinValue { get => Decimal.MinValue; } + public static Decimal MinusOne { get => Decimal.MinusOne; } + public static Decimal One { get => Decimal.One; } + public static Decimal Zero { get => Decimal.Zero; } #endregion diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs index 784cf35..ccee3bb 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs @@ -23,12 +23,12 @@ public double Value get => Decrypt(); } - public Double Epsilon { get => Double.Epsilon; } - public Double MaxValue { get => Double.MaxValue; } - public Double MinValue { get => Double.MinValue; } - public Double NaN { get => Double.NaN; } - public Double NegativeInfinity { get => Double.NegativeInfinity; } - public Double PositiveInfinity { get => Double.PositiveInfinity; } + public static Double Epsilon { get => Double.Epsilon; } + public static Double MaxValue { get => Double.MaxValue; } + public static Double MinValue { get => Double.MinValue; } + public static Double NaN { get => Double.NaN; } + public static Double NegativeInfinity { get => Double.NegativeInfinity; } + public static Double PositiveInfinity { get => Double.PositiveInfinity; } #endregion diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs index f11acb8..9bc4854 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs @@ -23,12 +23,12 @@ private float Value get => (float)Decrypt(); } - public float Epsilon { get => Single.Epsilon; } - public float MaxValue { get => Single.MaxValue; } - public float MinValue { get => Single.MinValue; } - public float NaN { get => Single.NaN; } - public float NegativeInfinity { get => Single.NegativeInfinity; } - public float PositiveInfinity { get => Single.PositiveInfinity; } + public static float Epsilon { get => Single.Epsilon; } + public static float MaxValue { get => Single.MaxValue; } + public static float MinValue { get => Single.MinValue; } + public static float NaN { get => Single.NaN; } + public static float NegativeInfinity { get => Single.NegativeInfinity; } + public static float PositiveInfinity { get => Single.PositiveInfinity; } #endregion diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs index dc65089..c52fab9 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs @@ -23,8 +23,8 @@ private int Value get => (int)Decrypt(); } - public int MaxValue { get => Int32.MaxValue; } - public int MinValue { get => Int32.MinValue; } + public static int MaxValue { get => Int32.MaxValue; } + public static int MinValue { get => Int32.MinValue; } private EncInt(double value) { diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs index e5fd407..267be0a 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs @@ -23,8 +23,8 @@ private long Value get => (long)Decrypt(); } - public long MaxValue { get => Int64.MaxValue; } - public long MinValue { get => Int64.MinValue; } + public static long MaxValue { get => Int64.MaxValue; } + public static long MinValue { get => Int64.MinValue; } private EncLong(decimal value) { From 89ebc6aa4d7a30990e5457eea41a995a656e3df9 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 06:00:35 +0200 Subject: [PATCH 14/53] EncLong/Double/Decimal Update - Remade the encryption algorithm in the EncDouble/Long/Decimal types. It has a severe issue that resulted in data loss. - Improved performace in EncLong and EncDecimal by 40% to 100% - The performance of the EncDouble has been decreased by 100%. It's quite a lot, but now it's functioning correctly without the data loss bug, so it's worth it. --- .../Variable-Encryption/Types/EncDecimal.cs | 41 ++++++++++++++---- .../Variable-Encryption/Types/EncDouble.cs | 31 ++++++++++---- .../Variable-Encryption/Types/EncLong.cs | 42 ++++++++++++++----- 3 files changed, 86 insertions(+), 28 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs index 55cd505..84d5a39 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs @@ -10,12 +10,10 @@ public struct EncDecimal #region Variables And Properties - // The encryption values - private readonly decimal encryptionKey1; - private readonly decimal encryptionKey2; + private readonly int[] encryptionKeys; // The encrypted value stored in memory - private readonly decimal encryptedValue; + private readonly int[] encryptedValue; // The decrypted value private decimal Value @@ -35,19 +33,44 @@ private decimal Value private EncDecimal(decimal value) { - encryptionKey1 = (decimal)(random.NextDouble() * 0.001); - encryptionKey2 = (decimal)(random.NextDouble() * 100); - encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + encryptionKeys = EncKeys(); + encryptedValue = Encrypt(value, encryptionKeys); } // Encryption key generator static private Random random = new Random(); + private static int[] EncKeys() + { + var arr = new int[4]; + for (int i = 0; i < 4; i++) + { + arr[i] = random.Next(); + } + return arr; + } + // Takes a given value and returns it encrypted - private static decimal Encrypt(decimal value, decimal k1, decimal k2) => (value * k1) * k2; + private static int[] Encrypt(decimal value, int[] keys) + { + var valueInBits = decimal.GetBits(value); + for (int i = 0; i < 4; i++) + { + valueInBits[i] ^= keys[i]; + } + return valueInBits; + } // Takes an encrypted value and returns it decrypted - private decimal Decrypt() => (encryptedValue / encryptionKey2) / encryptionKey1; + private decimal Decrypt() + { + var decrypted = new int[4]; + for (int i = 0; i < 4; i++) + { + decrypted[i] = encryptedValue[i] ^ encryptionKeys[i]; + } + return new decimal(decrypted); + } // Overrides public int CompareTo(Decimal value) => Value.CompareTo(value); diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs index ccee3bb..5a1a7ad 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs @@ -11,11 +11,10 @@ public struct EncDouble #region Variables And Properties // The encryption values - private readonly double encryptionKey1; - private readonly double encryptionKey2; + private readonly byte[] encryptionKeys; // The encrypted value stored in memory - private readonly double encryptedValue; + private readonly byte[] encryptedValue; // The decrypted value public double Value @@ -36,19 +35,35 @@ public double Value private EncDouble(double value) { - encryptionKey1 = random.NextDouble() * 0.001; - encryptionKey2 = random.NextDouble() * 100; - encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + encryptionKeys = new byte[8]; + random.NextBytes(encryptionKeys); + encryptedValue = Encrypt(value, encryptionKeys); } // Encryption key generator static private Random random = new Random(); // Takes a given value and returns it encrypted - private static double Encrypt(double value, double k1, double k2) => (value * k1) * k2; + private static byte[] Encrypt(double value, byte[] keys) + { + var valueBytes = BitConverter.GetBytes(value); + for (int i = 0; i < 8; i++) + { + valueBytes[i] ^= keys[i]; + } + return valueBytes; + } // Takes an encrypted value and returns it decrypted - private double Decrypt() => (encryptedValue / encryptionKey2) / encryptionKey1; + private double Decrypt() + { + var valueBytes = new byte[8]; + for (int i = 0; i < 8; i++) + { + valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); + } + return BitConverter.ToDouble(valueBytes); + } // Overrides public int CompareTo(object value) => Value.CompareTo(value); diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs index 267be0a..a65b132 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs @@ -10,37 +10,51 @@ public struct EncLong #region Variables - Properties - Methods - Constructors - // The encryption values - private readonly decimal encryptionKey1; - private readonly decimal encryptionKey2; + private readonly byte[] encryptionKeys; // The encrypted value stored in memory - private readonly decimal encryptedValue; + private readonly byte[] encryptedValue; // The decrypted value private long Value { - get => (long)Decrypt(); + get => Decrypt(); } public static long MaxValue { get => Int64.MaxValue; } public static long MinValue { get => Int64.MinValue; } - private EncLong(decimal value) + private EncLong(long value) { - encryptionKey1 = (decimal)(random.NextDouble() * 0.001); - encryptionKey2 = (decimal)(random.NextDouble() * 100); - encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + encryptionKeys = new byte[8]; + random.NextBytes(encryptionKeys); + encryptedValue = Encrypt(value, encryptionKeys); } // Encryption Key Generator static private Random random = new Random(); // Takes a given value and returns it encrypted - private static decimal Encrypt(decimal value, decimal k1, decimal k2) => (value + k1) * k2; + private static byte[] Encrypt(long value, byte[] keys) + { + var valueBytes = BitConverter.GetBytes(value); + for (int i = 0; i < 8; i++) + { + valueBytes[i] ^= keys[i]; + } + return valueBytes; + } // Takes an encrypted value and returns it decrypted - private decimal Decrypt() => ((encryptedValue / encryptionKey2) - encryptionKey1) + 0.5m; + private long Decrypt() + { + var valueBytes = new byte[8]; + for (int i = 0; i < 8; i++) + { + valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); + } + return BitConverter.ToInt64(valueBytes); + } // Int64 methods public int CompareTo(object value) => Value.CompareTo(value); @@ -161,6 +175,12 @@ private EncLong(decimal value) /// assign public static implicit operator EncLong(long value) => new EncLong(value); + public static implicit operator EncLong(int value) => new EncLong(value); + public static implicit operator EncLong(uint value) => new EncLong(value); + public static implicit operator EncLong(ushort value) => new EncLong(value); + public static implicit operator EncLong(short value) => new EncLong(value); + public static implicit operator EncLong(byte value) => new EncLong(value); + public static implicit operator EncLong(sbyte value) => new EncLong(value); public static explicit operator ulong(EncLong elong1) => (ulong)elong1.Value; public static implicit operator long(EncLong elong1) => elong1.Value; public static explicit operator uint(EncLong elong1) => (uint)elong1.Value; From fbd2a704a4744d41d08b86dfa7d594563ef1eb01 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 06:01:32 +0200 Subject: [PATCH 15/53] Added old types to the benchmark --- .../OldTypes/EncDecimal_0_5_0.cs | 137 ++++++++++ .../OldTypes/EncDecimal_0_7_0.cs | 244 ++++++++++++++++++ .../OldTypes/EncDecimal_0_8_0.cs | 241 +++++++++++++++++ .../OldTypes/EncDecimal_0_9_0.cs | 220 ++++++++++++++++ .../OldTypes/EncDouble_0_9_0.cs | 213 +++++++++++++++ .../OldTypes/EncLong_0_3_0.cs | 133 ++++++++++ .../OldTypes/EncLong_0_7_0.cs | 196 ++++++++++++++ .../OldTypes/EncLong_0_8_0.cs | 193 ++++++++++++++ .../OldTypes/EncLong_0_9_0.cs | 172 ++++++++++++ 9 files changed, 1749 insertions(+) create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_7_0.cs create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_9_0.cs create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_3_0.cs create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_7_0.cs create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_8_0.cs create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_9_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs new file mode 100644 index 0000000..33f25f9 --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs @@ -0,0 +1,137 @@ +using System; + +public struct EncDecimal_0_5_0 +{ + /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an deciaml. + /// + /// Wiki page: https://github.com/JosepeDev/Variable-Encryption/wiki + + #region Content + + #region Encryption Key Generator + + // The Random class for getting the random numbers + static private Random random = new Random(); + + // Returns a random decimal between 1 and 10 + public static decimal GetEncryptionKey() + { + return (decimal)(random.NextDouble()); + } + + #endregion + + #region Variables + + // The encryption values + private decimal encryptionKey1; + private decimal encryptionKey2; + + // The encrypted value stored in memory + private decimal encryptedValue; + + // The decrypted value + private decimal Value + { + set + { + encryptedValue = encrypt(value); + } + get + { + return (decimal)decrypt(encryptedValue); + } + } + + #endregion + + #region Constructors + + public static EncDecimal_0_5_0 NewEncDecimal(decimal value) + { + EncDecimal_0_5_0 theEncdecimal = new EncDecimal_0_5_0 + { + encryptionKey1 = GetEncryptionKey(), + encryptionKey2 = GetEncryptionKey(), + Value = value + }; + return theEncdecimal; + } + + #endregion + + #region Methods + + // Takes a given value and returns it encrypted + private decimal encrypt(decimal value) + { + decimal valueToReturn = value; + valueToReturn += encryptionKey1; + valueToReturn *= encryptionKey2; + return valueToReturn; + } + + // Takes an encrypted value and returns it decrypted + private decimal decrypt(decimal value) + { + decimal valueToReturn = value; + valueToReturn /= encryptionKey2; + valueToReturn -= encryptionKey1; + return valueToReturn; + } + + // Returns the stored value as a string + public override string ToString() + { + return (Value).ToString(); + } + + // Not recommended to use + public override bool Equals(object obj) + { + return obj is EncDecimal_0_5_0 ecndecimal && + Value == ecndecimal.Value; + } + public override int GetHashCode() + { + return (int)Value; + } + + #endregion + + #region Operators Overloading + + /// + - * / % + public static EncDecimal_0_5_0 operator +(EncDecimal_0_5_0 eint1, EncDecimal_0_5_0 eint2) => EncDecimal_0_5_0.NewEncDecimal(eint1.Value + eint2.Value); + public static EncDecimal_0_5_0 operator -(EncDecimal_0_5_0 eint1, EncDecimal_0_5_0 eint2) => EncDecimal_0_5_0.NewEncDecimal(eint1.Value - eint2.Value); + public static EncDecimal_0_5_0 operator *(EncDecimal_0_5_0 eint1, EncDecimal_0_5_0 eint2) => EncDecimal_0_5_0.NewEncDecimal(eint1.Value * eint2.Value); + public static EncDecimal_0_5_0 operator /(EncDecimal_0_5_0 eint1, EncDecimal_0_5_0 eint2) => EncDecimal_0_5_0.NewEncDecimal(eint1.Value / eint2.Value); + public static EncDecimal_0_5_0 operator %(EncDecimal_0_5_0 eint1, EncDecimal_0_5_0 eint2) => EncDecimal_0_5_0.NewEncDecimal(eint1.Value % eint2.Value); + + public static decimal operator +(EncDecimal_0_5_0 edecimal1, decimal edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_5_0 edecimal1, decimal edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_5_0 edecimal1, decimal edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_5_0 edecimal1, decimal edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_5_0 edecimal1, decimal edecimal2) => edecimal1.Value % edecimal2; + + /// == != < > + public static bool operator ==(EncDecimal_0_5_0 eint1, decimal eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_5_0 eint1, decimal eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_5_0 eint1, decimal eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_5_0 eint1, decimal eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_5_0 eint1, EncDecimal_0_5_0 eint2) => eint1.Value == eint2.Value; + public static bool operator !=(EncDecimal_0_5_0 eint1, EncDecimal_0_5_0 eint2) => eint1.Value != eint2.Value; + public static bool operator <(EncDecimal_0_5_0 eint1, EncDecimal_0_5_0 eint2) => eint1.Value < eint2.Value; + public static bool operator >(EncDecimal_0_5_0 eint1, EncDecimal_0_5_0 eint2) => eint1.Value > eint2.Value; + + /// assign + public static implicit operator EncDecimal_0_5_0(decimal value) => EncDecimal_0_5_0.NewEncDecimal(value); + public static implicit operator decimal(EncDecimal_0_5_0 eint1) => eint1.Value; + + #endregion + + #endregion +} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_7_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_7_0.cs new file mode 100644 index 0000000..d143c3b --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_7_0.cs @@ -0,0 +1,244 @@ +using System; + +public struct EncDecimal_0_7_0 +{ + /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an deciaml. + /// + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + + #region Variables And Properties + + // The encryption values + private decimal encryptionKey1; + private decimal encryptionKey2; + + // The encrypted value stored in memory + private decimal encryptedValue; + + // The decrypted value + public decimal Value + { + set + { + encryptedValue = Encrypt(value); + } + get + { + return (decimal)Decrypt(encryptedValue); + } + } + + public Decimal MaxValue { get => Decimal.MaxValue; } + public Decimal MinValue { get => Decimal.MinValue; } + public Decimal MinusOne { get => Decimal.MinusOne; } + public Decimal One { get => Decimal.One; } + public Decimal Zero { get => Decimal.Zero; } + + #endregion + + #region Methods + + private static EncDecimal_0_7_0 NewEncDecimal(decimal value) + { + EncDecimal_0_7_0 theEncdecimal = new EncDecimal_0_7_0 + { + encryptionKey1 = GetEncryptionKey(), + encryptionKey2 = GetEncryptionKey(), + Value = value + }; + return theEncdecimal; + } + + // Encryption key generator + static private Random random = new Random(); + static private decimal GetEncryptionKey() => (decimal)(random.NextDouble()); + + // Takes a given value and returns it encrypted + private decimal Encrypt(decimal value) + { + decimal valueToReturn = value; + valueToReturn += encryptionKey1; + valueToReturn *= encryptionKey2; + return valueToReturn; + } + + // Takes an encrypted value and returns it decrypted + private decimal Decrypt(decimal value) + { + decimal valueToReturn = value; + valueToReturn /= encryptionKey2; + valueToReturn -= encryptionKey1; + return valueToReturn; + } + + // Overrides + public int CompareTo(Decimal value) => Value.CompareTo(value); + public int CompareTo(object value) => Value.CompareTo(value); + public bool Equals(Decimal value) => Value.Equals(value); + public override bool Equals(object value) => Value.Equals(value); + public override int GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public string ToString(string format) => Value.ToString(format); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public override string ToString() => Value.ToString(); + public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + + #endregion + + #region Operators Overloading + + /// + - * / % + + public static EncDecimal_0_7_0 operator +(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => EncDecimal_0_7_0.NewEncDecimal(eint1.Value + eint2.Value); + public static EncDecimal_0_7_0 operator -(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => EncDecimal_0_7_0.NewEncDecimal(eint1.Value - eint2.Value); + public static EncDecimal_0_7_0 operator *(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => EncDecimal_0_7_0.NewEncDecimal(eint1.Value * eint2.Value); + public static EncDecimal_0_7_0 operator /(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => EncDecimal_0_7_0.NewEncDecimal(eint1.Value / eint2.Value); + public static EncDecimal_0_7_0 operator %(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => EncDecimal_0_7_0.NewEncDecimal(eint1.Value % eint2.Value); + + public static decimal operator +(EncDecimal_0_7_0 edecimal1, ulong edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_7_0 edecimal1, ulong edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_7_0 edecimal1, ulong edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_7_0 edecimal1, ulong edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_7_0 edecimal1, ulong edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_7_0 edecimal1, long edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_7_0 edecimal1, long edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_7_0 edecimal1, long edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_7_0 edecimal1, long edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_7_0 edecimal1, long edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_7_0 edecimal1, uint edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_7_0 edecimal1, uint edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_7_0 edecimal1, uint edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_7_0 edecimal1, uint edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_7_0 edecimal1, uint edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_7_0 edecimal1, int edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_7_0 edecimal1, int edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_7_0 edecimal1, int edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_7_0 edecimal1, int edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_7_0 edecimal1, int edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_7_0 edecimal1, ushort edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_7_0 edecimal1, ushort edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_7_0 edecimal1, ushort edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_7_0 edecimal1, ushort edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_7_0 edecimal1, ushort edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_7_0 edecimal1, short edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_7_0 edecimal1, short edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_7_0 edecimal1, short edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_7_0 edecimal1, short edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_7_0 edecimal1, short edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_7_0 edecimal1, byte edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_7_0 edecimal1, byte edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_7_0 edecimal1, byte edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_7_0 edecimal1, byte edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_7_0 edecimal1, byte edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_7_0 edecimal1, sbyte edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_7_0 edecimal1, sbyte edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_7_0 edecimal1, sbyte edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_7_0 edecimal1, sbyte edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_7_0 edecimal1, sbyte edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_7_0 edecimal1, decimal edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_7_0 edecimal1, decimal edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_7_0 edecimal1, decimal edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_7_0 edecimal1, decimal edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_7_0 edecimal1, decimal edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_7_0 edecimal1, double edecimal2) => edecimal1.Value + (decimal)edecimal2; + public static decimal operator -(EncDecimal_0_7_0 edecimal1, double edecimal2) => edecimal1.Value - (decimal)edecimal2; + public static decimal operator *(EncDecimal_0_7_0 edecimal1, double edecimal2) => edecimal1.Value * (decimal)edecimal2; + public static decimal operator /(EncDecimal_0_7_0 edecimal1, double edecimal2) => edecimal1.Value / (decimal)edecimal2; + public static decimal operator %(EncDecimal_0_7_0 edecimal1, double edecimal2) => edecimal1.Value % (decimal)edecimal2; + + public static decimal operator +(EncDecimal_0_7_0 edecimal1, float edecimal2) => edecimal1.Value + (decimal)edecimal2; + public static decimal operator -(EncDecimal_0_7_0 edecimal1, float edecimal2) => edecimal1.Value - (decimal)edecimal2; + public static decimal operator *(EncDecimal_0_7_0 edecimal1, float edecimal2) => edecimal1.Value * (decimal)edecimal2; + public static decimal operator /(EncDecimal_0_7_0 edecimal1, float edecimal2) => edecimal1.Value / (decimal)edecimal2; + public static decimal operator %(EncDecimal_0_7_0 edecimal1, float edecimal2) => edecimal1.Value % (decimal)edecimal2; + + /// == != < > + + public static bool operator ==(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => eint1.Value == eint2.Value; + public static bool operator !=(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => eint1.Value != eint2.Value; + public static bool operator <(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => eint1.Value < eint2.Value; + public static bool operator >(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => eint1.Value > eint2.Value; + + public static bool operator ==(EncDecimal_0_7_0 eint1, ulong eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_7_0 eint1, ulong eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_7_0 eint1, ulong eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_7_0 eint1, ulong eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_7_0 eint1, long eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_7_0 eint1, long eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_7_0 eint1, long eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_7_0 eint1, long eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_7_0 eint1, uint eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_7_0 eint1, uint eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_7_0 eint1, uint eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_7_0 eint1, uint eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_7_0 eint1, int eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_7_0 eint1, int eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_7_0 eint1, int eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_7_0 eint1, int eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_7_0 eint1, ushort eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_7_0 eint1, ushort eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_7_0 eint1, ushort eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_7_0 eint1, ushort eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_7_0 eint1, short eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_7_0 eint1, short eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_7_0 eint1, short eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_7_0 eint1, short eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_7_0 eint1, byte eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_7_0 eint1, byte eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_7_0 eint1, byte eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_7_0 eint1, byte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_7_0 eint1, sbyte eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_7_0 eint1, sbyte eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_7_0 eint1, sbyte eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_7_0 eint1, sbyte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_7_0 eint1, decimal eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_7_0 eint1, decimal eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_7_0 eint1, decimal eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_7_0 eint1, decimal eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_7_0 eint1, double eint2) => eint1.Value == (decimal)eint2; + public static bool operator !=(EncDecimal_0_7_0 eint1, double eint2) => eint1.Value != (decimal)eint2; + public static bool operator >(EncDecimal_0_7_0 eint1, double eint2) => eint1.Value > (decimal)eint2; + public static bool operator <(EncDecimal_0_7_0 eint1, double eint2) => eint1.Value < (decimal)eint2; + + public static bool operator ==(EncDecimal_0_7_0 eint1, float eint2) => eint1.Value == (decimal)eint2; + public static bool operator !=(EncDecimal_0_7_0 eint1, float eint2) => eint1.Value != (decimal)eint2; + public static bool operator >(EncDecimal_0_7_0 eint1, float eint2) => eint1.Value > (decimal)eint2; + public static bool operator <(EncDecimal_0_7_0 eint1, float eint2) => eint1.Value < (decimal)eint2; + + /// assign + + public static implicit operator EncDecimal_0_7_0(decimal value) => EncDecimal_0_7_0.NewEncDecimal(value); + public static implicit operator decimal(EncDecimal_0_7_0 eint1) => eint1.Value; + public static explicit operator double(EncDecimal_0_7_0 eint1) => (double)eint1.Value; + public static explicit operator float(EncDecimal_0_7_0 eint1) => (float)eint1.Value; + public static explicit operator ulong(EncDecimal_0_7_0 eint1) => (ulong)eint1.Value; + public static explicit operator long(EncDecimal_0_7_0 eint1) => (long)eint1.Value; + public static explicit operator uint(EncDecimal_0_7_0 eint1) => (uint)eint1.Value; + public static explicit operator int(EncDecimal_0_7_0 eint1) => (int)eint1.Value; + public static explicit operator ushort(EncDecimal_0_7_0 eint1) => (ushort)eint1.Value; + public static explicit operator short(EncDecimal_0_7_0 eint1) => (short)eint1.Value; + public static explicit operator byte(EncDecimal_0_7_0 eint1) => (byte)eint1.Value; + public static explicit operator sbyte(EncDecimal_0_7_0 eint1) => (sbyte)eint1.Value; + + #endregion +} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs new file mode 100644 index 0000000..173c04b --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs @@ -0,0 +1,241 @@ +using System; + +public struct EncDecimal_0_8_0 +{ + /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an deciaml. + /// + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + + #region Variables And Properties + + // The encryption values + private decimal encryptionKey1; + private decimal encryptionKey2; + + // The encrypted value stored in memory + private decimal encryptedValue; + + // The decrypted value + public decimal Value + { + set + { + encryptedValue = Encrypt(value); + } + get + { + return (decimal)Decrypt(encryptedValue); + } + } + + public Decimal MaxValue { get => Decimal.MaxValue; } + public Decimal MinValue { get => Decimal.MinValue; } + public Decimal MinusOne { get => Decimal.MinusOne; } + public Decimal One { get => Decimal.One; } + public Decimal Zero { get => Decimal.Zero; } + + #endregion + + #region Methods & Constructors + + private EncDecimal_0_8_0(decimal value) + { + encryptionKey1 = GetEncryptionKey(); + encryptionKey2 = GetEncryptionKey(); + encryptedValue = 0; + Value = value; + } + + // Encryption key generator + static private Random random = new Random(); + static private decimal GetEncryptionKey() => (decimal)(random.NextDouble()); + + // Takes a given value and returns it encrypted + private decimal Encrypt(decimal value) + { + decimal valueToReturn = value; + valueToReturn += encryptionKey1; + valueToReturn *= encryptionKey2; + return valueToReturn; + } + + // Takes an encrypted value and returns it decrypted + private decimal Decrypt(decimal value) + { + decimal valueToReturn = value; + valueToReturn /= encryptionKey2; + valueToReturn -= encryptionKey1; + return valueToReturn; + } + + // Overrides + public int CompareTo(Decimal value) => Value.CompareTo(value); + public int CompareTo(object value) => Value.CompareTo(value); + public bool Equals(Decimal value) => Value.Equals(value); + public override bool Equals(object value) => Value.Equals(value); + public override int GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public string ToString(string format) => Value.ToString(format); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public override string ToString() => Value.ToString(); + public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + + #endregion + + #region Operators Overloading + + /// + - * / % + + public static EncDecimal_0_8_0 operator +(EncDecimal_0_8_0 eint1, EncDecimal_0_8_0 eint2) => new EncDecimal_0_8_0(eint1.Value + eint2.Value); + public static EncDecimal_0_8_0 operator -(EncDecimal_0_8_0 eint1, EncDecimal_0_8_0 eint2) => new EncDecimal_0_8_0(eint1.Value - eint2.Value); + public static EncDecimal_0_8_0 operator *(EncDecimal_0_8_0 eint1, EncDecimal_0_8_0 eint2) => new EncDecimal_0_8_0(eint1.Value * eint2.Value); + public static EncDecimal_0_8_0 operator /(EncDecimal_0_8_0 eint1, EncDecimal_0_8_0 eint2) => new EncDecimal_0_8_0(eint1.Value / eint2.Value); + public static EncDecimal_0_8_0 operator %(EncDecimal_0_8_0 eint1, EncDecimal_0_8_0 eint2) => new EncDecimal_0_8_0(eint1.Value % eint2.Value); + + public static decimal operator +(EncDecimal_0_8_0 edecimal1, ulong edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_8_0 edecimal1, ulong edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_8_0 edecimal1, ulong edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_8_0 edecimal1, ulong edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_8_0 edecimal1, ulong edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_8_0 edecimal1, long edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_8_0 edecimal1, long edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_8_0 edecimal1, long edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_8_0 edecimal1, long edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_8_0 edecimal1, long edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_8_0 edecimal1, uint edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_8_0 edecimal1, uint edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_8_0 edecimal1, uint edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_8_0 edecimal1, uint edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_8_0 edecimal1, uint edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_8_0 edecimal1, int edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_8_0 edecimal1, int edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_8_0 edecimal1, int edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_8_0 edecimal1, int edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_8_0 edecimal1, int edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_8_0 edecimal1, ushort edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_8_0 edecimal1, ushort edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_8_0 edecimal1, ushort edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_8_0 edecimal1, ushort edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_8_0 edecimal1, ushort edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_8_0 edecimal1, short edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_8_0 edecimal1, short edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_8_0 edecimal1, short edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_8_0 edecimal1, short edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_8_0 edecimal1, short edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_8_0 edecimal1, byte edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_8_0 edecimal1, byte edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_8_0 edecimal1, byte edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_8_0 edecimal1, byte edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_8_0 edecimal1, byte edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_8_0 edecimal1, sbyte edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_8_0 edecimal1, sbyte edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_8_0 edecimal1, sbyte edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_8_0 edecimal1, sbyte edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_8_0 edecimal1, sbyte edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_8_0 edecimal1, decimal edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_8_0 edecimal1, decimal edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_8_0 edecimal1, decimal edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_8_0 edecimal1, decimal edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_8_0 edecimal1, decimal edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_8_0 edecimal1, double edecimal2) => edecimal1.Value + (decimal)edecimal2; + public static decimal operator -(EncDecimal_0_8_0 edecimal1, double edecimal2) => edecimal1.Value - (decimal)edecimal2; + public static decimal operator *(EncDecimal_0_8_0 edecimal1, double edecimal2) => edecimal1.Value * (decimal)edecimal2; + public static decimal operator /(EncDecimal_0_8_0 edecimal1, double edecimal2) => edecimal1.Value / (decimal)edecimal2; + public static decimal operator %(EncDecimal_0_8_0 edecimal1, double edecimal2) => edecimal1.Value % (decimal)edecimal2; + + public static decimal operator +(EncDecimal_0_8_0 edecimal1, float edecimal2) => edecimal1.Value + (decimal)edecimal2; + public static decimal operator -(EncDecimal_0_8_0 edecimal1, float edecimal2) => edecimal1.Value - (decimal)edecimal2; + public static decimal operator *(EncDecimal_0_8_0 edecimal1, float edecimal2) => edecimal1.Value * (decimal)edecimal2; + public static decimal operator /(EncDecimal_0_8_0 edecimal1, float edecimal2) => edecimal1.Value / (decimal)edecimal2; + public static decimal operator %(EncDecimal_0_8_0 edecimal1, float edecimal2) => edecimal1.Value % (decimal)edecimal2; + + /// == != < > + + public static bool operator ==(EncDecimal_0_8_0 eint1, EncDecimal_0_8_0 eint2) => eint1.Value == eint2.Value; + public static bool operator !=(EncDecimal_0_8_0 eint1, EncDecimal_0_8_0 eint2) => eint1.Value != eint2.Value; + public static bool operator <(EncDecimal_0_8_0 eint1, EncDecimal_0_8_0 eint2) => eint1.Value < eint2.Value; + public static bool operator >(EncDecimal_0_8_0 eint1, EncDecimal_0_8_0 eint2) => eint1.Value > eint2.Value; + + public static bool operator ==(EncDecimal_0_8_0 eint1, ulong eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_8_0 eint1, ulong eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_8_0 eint1, ulong eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_8_0 eint1, ulong eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_8_0 eint1, long eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_8_0 eint1, long eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_8_0 eint1, long eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_8_0 eint1, long eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_8_0 eint1, uint eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_8_0 eint1, uint eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_8_0 eint1, uint eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_8_0 eint1, uint eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_8_0 eint1, int eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_8_0 eint1, int eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_8_0 eint1, int eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_8_0 eint1, int eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_8_0 eint1, ushort eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_8_0 eint1, ushort eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_8_0 eint1, ushort eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_8_0 eint1, ushort eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_8_0 eint1, short eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_8_0 eint1, short eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_8_0 eint1, short eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_8_0 eint1, short eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_8_0 eint1, byte eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_8_0 eint1, byte eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_8_0 eint1, byte eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_8_0 eint1, byte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_8_0 eint1, sbyte eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_8_0 eint1, sbyte eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_8_0 eint1, sbyte eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_8_0 eint1, sbyte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_8_0 eint1, decimal eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_8_0 eint1, decimal eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_8_0 eint1, decimal eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_8_0 eint1, decimal eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_8_0 eint1, double eint2) => eint1.Value == (decimal)eint2; + public static bool operator !=(EncDecimal_0_8_0 eint1, double eint2) => eint1.Value != (decimal)eint2; + public static bool operator >(EncDecimal_0_8_0 eint1, double eint2) => eint1.Value > (decimal)eint2; + public static bool operator <(EncDecimal_0_8_0 eint1, double eint2) => eint1.Value < (decimal)eint2; + + public static bool operator ==(EncDecimal_0_8_0 eint1, float eint2) => eint1.Value == (decimal)eint2; + public static bool operator !=(EncDecimal_0_8_0 eint1, float eint2) => eint1.Value != (decimal)eint2; + public static bool operator >(EncDecimal_0_8_0 eint1, float eint2) => eint1.Value > (decimal)eint2; + public static bool operator <(EncDecimal_0_8_0 eint1, float eint2) => eint1.Value < (decimal)eint2; + + /// assign + + public static implicit operator EncDecimal_0_8_0(decimal value) => new EncDecimal_0_8_0(value); + public static implicit operator decimal(EncDecimal_0_8_0 eint1) => eint1.Value; + public static explicit operator double(EncDecimal_0_8_0 eint1) => (double)eint1.Value; + public static explicit operator float(EncDecimal_0_8_0 eint1) => (float)eint1.Value; + public static explicit operator ulong(EncDecimal_0_8_0 eint1) => (ulong)eint1.Value; + public static explicit operator long(EncDecimal_0_8_0 eint1) => (long)eint1.Value; + public static explicit operator uint(EncDecimal_0_8_0 eint1) => (uint)eint1.Value; + public static explicit operator int(EncDecimal_0_8_0 eint1) => (int)eint1.Value; + public static explicit operator ushort(EncDecimal_0_8_0 eint1) => (ushort)eint1.Value; + public static explicit operator short(EncDecimal_0_8_0 eint1) => (short)eint1.Value; + public static explicit operator byte(EncDecimal_0_8_0 eint1) => (byte)eint1.Value; + public static explicit operator sbyte(EncDecimal_0_8_0 eint1) => (sbyte)eint1.Value; + + #endregion +} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs new file mode 100644 index 0000000..0119a00 --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs @@ -0,0 +1,220 @@ +using System; + +public struct EncDecimal_0_9_0 +{ + /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an deciaml. + /// + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + + #region Variables And Properties + + // The encryption values + private readonly decimal encryptionKey1; + private readonly decimal encryptionKey2; + + // The encrypted value stored in memory + private readonly decimal encryptedValue; + + // The decrypted value + private decimal Value + { + get => Decrypt(); + } + + public Decimal MaxValue { get => Decimal.MaxValue; } + public Decimal MinValue { get => Decimal.MinValue; } + public Decimal MinusOne { get => Decimal.MinusOne; } + public Decimal One { get => Decimal.One; } + public Decimal Zero { get => Decimal.Zero; } + + #endregion + + #region Methods & Constructors + + private EncDecimal_0_9_0(decimal value) + { + encryptionKey1 = (decimal)random.NextDouble(); + encryptionKey2 = (decimal)random.NextDouble(); + encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + } + + // Encryption key generator + static private Random random = new Random(); + + // Takes a given value and returns it encrypted + private static decimal Encrypt(decimal value, decimal k1, decimal k2) => (value + k1) * k2; + + // Takes an encrypted value and returns it decrypted + private decimal Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + + // Overrides + public int CompareTo(Decimal value) => Value.CompareTo(value); + public int CompareTo(object value) => Value.CompareTo(value); + public bool Equals(Decimal value) => Value.Equals(value); + public override bool Equals(object value) => Value.Equals(value); + public override int GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public string ToString(string format) => Value.ToString(format); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public override string ToString() => Value.ToString(); + public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + + #endregion + + #region Operators Overloading + + /// + - * / % + + public static EncDecimal_0_9_0 operator +(EncDecimal_0_9_0 eint1, EncDecimal_0_9_0 eint2) => new EncDecimal_0_9_0(eint1.Value + eint2.Value); + public static EncDecimal_0_9_0 operator -(EncDecimal_0_9_0 eint1, EncDecimal_0_9_0 eint2) => new EncDecimal_0_9_0(eint1.Value - eint2.Value); + public static EncDecimal_0_9_0 operator *(EncDecimal_0_9_0 eint1, EncDecimal_0_9_0 eint2) => new EncDecimal_0_9_0(eint1.Value * eint2.Value); + public static EncDecimal_0_9_0 operator /(EncDecimal_0_9_0 eint1, EncDecimal_0_9_0 eint2) => new EncDecimal_0_9_0(eint1.Value / eint2.Value); + public static EncDecimal_0_9_0 operator %(EncDecimal_0_9_0 eint1, EncDecimal_0_9_0 eint2) => new EncDecimal_0_9_0(eint1.Value % eint2.Value); + + public static decimal operator +(EncDecimal_0_9_0 edecimal1, ulong edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_9_0 edecimal1, ulong edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_9_0 edecimal1, ulong edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_9_0 edecimal1, ulong edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_9_0 edecimal1, ulong edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_9_0 edecimal1, long edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_9_0 edecimal1, long edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_9_0 edecimal1, long edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_9_0 edecimal1, long edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_9_0 edecimal1, long edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_9_0 edecimal1, uint edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_9_0 edecimal1, uint edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_9_0 edecimal1, uint edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_9_0 edecimal1, uint edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_9_0 edecimal1, uint edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_9_0 edecimal1, int edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_9_0 edecimal1, int edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_9_0 edecimal1, int edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_9_0 edecimal1, int edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_9_0 edecimal1, int edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_9_0 edecimal1, ushort edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_9_0 edecimal1, ushort edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_9_0 edecimal1, ushort edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_9_0 edecimal1, ushort edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_9_0 edecimal1, ushort edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_9_0 edecimal1, short edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_9_0 edecimal1, short edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_9_0 edecimal1, short edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_9_0 edecimal1, short edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_9_0 edecimal1, short edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_9_0 edecimal1, byte edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_9_0 edecimal1, byte edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_9_0 edecimal1, byte edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_9_0 edecimal1, byte edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_9_0 edecimal1, byte edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_9_0 edecimal1, sbyte edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_9_0 edecimal1, sbyte edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_9_0 edecimal1, sbyte edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_9_0 edecimal1, sbyte edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_9_0 edecimal1, sbyte edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_9_0 edecimal1, decimal edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal_0_9_0 edecimal1, decimal edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal_0_9_0 edecimal1, decimal edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal_0_9_0 edecimal1, decimal edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal_0_9_0 edecimal1, decimal edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal_0_9_0 edecimal1, double edecimal2) => edecimal1.Value + (decimal)edecimal2; + public static decimal operator -(EncDecimal_0_9_0 edecimal1, double edecimal2) => edecimal1.Value - (decimal)edecimal2; + public static decimal operator *(EncDecimal_0_9_0 edecimal1, double edecimal2) => edecimal1.Value * (decimal)edecimal2; + public static decimal operator /(EncDecimal_0_9_0 edecimal1, double edecimal2) => edecimal1.Value / (decimal)edecimal2; + public static decimal operator %(EncDecimal_0_9_0 edecimal1, double edecimal2) => edecimal1.Value % (decimal)edecimal2; + + public static decimal operator +(EncDecimal_0_9_0 edecimal1, float edecimal2) => edecimal1.Value + (decimal)edecimal2; + public static decimal operator -(EncDecimal_0_9_0 edecimal1, float edecimal2) => edecimal1.Value - (decimal)edecimal2; + public static decimal operator *(EncDecimal_0_9_0 edecimal1, float edecimal2) => edecimal1.Value * (decimal)edecimal2; + public static decimal operator /(EncDecimal_0_9_0 edecimal1, float edecimal2) => edecimal1.Value / (decimal)edecimal2; + public static decimal operator %(EncDecimal_0_9_0 edecimal1, float edecimal2) => edecimal1.Value % (decimal)edecimal2; + + /// == != < > + + public static bool operator ==(EncDecimal_0_9_0 eint1, EncDecimal_0_9_0 eint2) => eint1.Value == eint2.Value; + public static bool operator !=(EncDecimal_0_9_0 eint1, EncDecimal_0_9_0 eint2) => eint1.Value != eint2.Value; + public static bool operator <(EncDecimal_0_9_0 eint1, EncDecimal_0_9_0 eint2) => eint1.Value < eint2.Value; + public static bool operator >(EncDecimal_0_9_0 eint1, EncDecimal_0_9_0 eint2) => eint1.Value > eint2.Value; + + public static bool operator ==(EncDecimal_0_9_0 eint1, ulong eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_9_0 eint1, ulong eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_9_0 eint1, ulong eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_9_0 eint1, ulong eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_9_0 eint1, long eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_9_0 eint1, long eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_9_0 eint1, long eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_9_0 eint1, long eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_9_0 eint1, uint eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_9_0 eint1, uint eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_9_0 eint1, uint eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_9_0 eint1, uint eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_9_0 eint1, int eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_9_0 eint1, int eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_9_0 eint1, int eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_9_0 eint1, int eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_9_0 eint1, ushort eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_9_0 eint1, ushort eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_9_0 eint1, ushort eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_9_0 eint1, ushort eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_9_0 eint1, short eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_9_0 eint1, short eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_9_0 eint1, short eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_9_0 eint1, short eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_9_0 eint1, byte eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_9_0 eint1, byte eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_9_0 eint1, byte eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_9_0 eint1, byte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_9_0 eint1, sbyte eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_9_0 eint1, sbyte eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_9_0 eint1, sbyte eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_9_0 eint1, sbyte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_9_0 eint1, decimal eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal_0_9_0 eint1, decimal eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal_0_9_0 eint1, decimal eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal_0_9_0 eint1, decimal eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal_0_9_0 eint1, double eint2) => eint1.Value == (decimal)eint2; + public static bool operator !=(EncDecimal_0_9_0 eint1, double eint2) => eint1.Value != (decimal)eint2; + public static bool operator >(EncDecimal_0_9_0 eint1, double eint2) => eint1.Value > (decimal)eint2; + public static bool operator <(EncDecimal_0_9_0 eint1, double eint2) => eint1.Value < (decimal)eint2; + + public static bool operator ==(EncDecimal_0_9_0 eint1, float eint2) => eint1.Value == (decimal)eint2; + public static bool operator !=(EncDecimal_0_9_0 eint1, float eint2) => eint1.Value != (decimal)eint2; + public static bool operator >(EncDecimal_0_9_0 eint1, float eint2) => eint1.Value > (decimal)eint2; + public static bool operator <(EncDecimal_0_9_0 eint1, float eint2) => eint1.Value < (decimal)eint2; + + /// assign + + public static implicit operator EncDecimal_0_9_0(decimal value) => new EncDecimal_0_9_0(value); + public static implicit operator decimal(EncDecimal_0_9_0 eint1) => eint1.Value; + public static explicit operator double(EncDecimal_0_9_0 eint1) => (double)eint1.Value; + public static explicit operator float(EncDecimal_0_9_0 eint1) => (float)eint1.Value; + public static explicit operator ulong(EncDecimal_0_9_0 eint1) => (ulong)eint1.Value; + public static explicit operator long(EncDecimal_0_9_0 eint1) => (long)eint1.Value; + public static explicit operator uint(EncDecimal_0_9_0 eint1) => (uint)eint1.Value; + public static explicit operator int(EncDecimal_0_9_0 eint1) => (int)eint1.Value; + public static explicit operator ushort(EncDecimal_0_9_0 eint1) => (ushort)eint1.Value; + public static explicit operator short(EncDecimal_0_9_0 eint1) => (short)eint1.Value; + public static explicit operator byte(EncDecimal_0_9_0 eint1) => (byte)eint1.Value; + public static explicit operator sbyte(EncDecimal_0_9_0 eint1) => (sbyte)eint1.Value; + + #endregion +} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_9_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_9_0.cs new file mode 100644 index 0000000..8ac4394 --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_9_0.cs @@ -0,0 +1,213 @@ +using System; + +public struct EncDouble_0_9_0 +{ + /// A struct for storing a Double while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an double. + /// + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + + #region Variables And Properties + + // The encryption values + private readonly double encryptionKey1; + private readonly double encryptionKey2; + + // The encrypted value stored in memory + private readonly double encryptedValue; + + // The decrypted value + public double Value + { + get => Decrypt(); + } + + public Double Epsilon { get => Double.Epsilon; } + public Double MaxValue { get => Double.MaxValue; } + public Double MinValue { get => Double.MinValue; } + public Double NaN { get => Double.NaN; } + public Double NegativeInfinity { get => Double.NegativeInfinity; } + public Double PositiveInfinity { get => Double.PositiveInfinity; } + + #endregion + + #region Methods & Constructors + + private EncDouble_0_9_0(double value) + { + encryptionKey1 = random.NextDouble(); + encryptionKey2 = random.NextDouble(); + encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + } + + // Encryption key generator + static private Random random = new Random(); + + // Takes a given value and returns it encrypted + private static double Encrypt(double value, double k1, double k2) => (value + k1) * k2; + + // Takes an encrypted value and returns it decrypted + private double Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + + // Overrides + public int CompareTo(object value) => Value.CompareTo(value); + public int CompareTo(Double value) => Value.CompareTo(value); + public bool Equals(Double obj) => Value.Equals(obj); + public override bool Equals(object obj) => Value.Equals(obj); + public override int GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public override string ToString() => Value.ToString(); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public string ToString(string format) => Value.ToString(format); + public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + + #endregion + + #region Operators Overloading + + /// + - * / % + public static EncDouble_0_9_0 operator +(EncDouble_0_9_0 eint1, EncDouble_0_9_0 eint2) => new EncDouble_0_9_0(eint1.Value + eint2.Value); + public static EncDouble_0_9_0 operator -(EncDouble_0_9_0 eint1, EncDouble_0_9_0 eint2) => new EncDouble_0_9_0(eint1.Value - eint2.Value); + public static EncDouble_0_9_0 operator *(EncDouble_0_9_0 eint1, EncDouble_0_9_0 eint2) => new EncDouble_0_9_0(eint1.Value * eint2.Value); + public static EncDouble_0_9_0 operator /(EncDouble_0_9_0 eint1, EncDouble_0_9_0 eint2) => new EncDouble_0_9_0(eint1.Value / eint2.Value); + public static EncDouble_0_9_0 operator %(EncDouble_0_9_0 eint1, EncDouble_0_9_0 eint2) => new EncDouble_0_9_0(eint1.Value % eint2.Value); + + public static double operator +(EncDouble_0_9_0 edouble1, ulong edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble_0_9_0 edouble1, ulong edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble_0_9_0 edouble1, ulong edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble_0_9_0 edouble1, ulong edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble_0_9_0 edouble1, ulong edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble_0_9_0 edouble1, long edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble_0_9_0 edouble1, long edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble_0_9_0 edouble1, long edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble_0_9_0 edouble1, long edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble_0_9_0 edouble1, long edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble_0_9_0 edouble1, uint edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble_0_9_0 edouble1, uint edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble_0_9_0 edouble1, uint edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble_0_9_0 edouble1, uint edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble_0_9_0 edouble1, uint edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble_0_9_0 edouble1, int edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble_0_9_0 edouble1, int edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble_0_9_0 edouble1, int edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble_0_9_0 edouble1, int edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble_0_9_0 edouble1, int edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble_0_9_0 edouble1, ushort edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble_0_9_0 edouble1, ushort edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble_0_9_0 edouble1, ushort edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble_0_9_0 edouble1, ushort edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble_0_9_0 edouble1, ushort edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble_0_9_0 edouble1, short edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble_0_9_0 edouble1, short edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble_0_9_0 edouble1, short edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble_0_9_0 edouble1, short edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble_0_9_0 edouble1, short edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble_0_9_0 edouble1, byte edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble_0_9_0 edouble1, byte edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble_0_9_0 edouble1, byte edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble_0_9_0 edouble1, byte edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble_0_9_0 edouble1, byte edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble_0_9_0 edouble1, sbyte edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble_0_9_0 edouble1, sbyte edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble_0_9_0 edouble1, sbyte edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble_0_9_0 edouble1, sbyte edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble_0_9_0 edouble1, sbyte edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble_0_9_0 edouble1, double edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble_0_9_0 edouble1, double edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble_0_9_0 edouble1, double edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble_0_9_0 edouble1, double edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble_0_9_0 edouble1, double edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble_0_9_0 edouble1, float edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble_0_9_0 edouble1, float edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble_0_9_0 edouble1, float edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble_0_9_0 edouble1, float edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble_0_9_0 edouble1, float edouble2) => edouble1.Value % edouble2; + + /// == != < > + + public static bool operator ==(EncDouble_0_9_0 eint1, EncDouble_0_9_0 eint2) => eint1.Value == eint2.Value; + public static bool operator !=(EncDouble_0_9_0 eint1, EncDouble_0_9_0 eint2) => eint1.Value != eint2.Value; + public static bool operator <(EncDouble_0_9_0 eint1, EncDouble_0_9_0 eint2) => eint1.Value < eint2.Value; + public static bool operator >(EncDouble_0_9_0 eint1, EncDouble_0_9_0 eint2) => eint1.Value > eint2.Value; + + public static bool operator ==(EncDouble_0_9_0 eint1, ulong eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble_0_9_0 eint1, ulong eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble_0_9_0 eint1, ulong eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble_0_9_0 eint1, ulong eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble_0_9_0 eint1, long eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble_0_9_0 eint1, long eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble_0_9_0 eint1, long eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble_0_9_0 eint1, long eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble_0_9_0 eint1, uint eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble_0_9_0 eint1, uint eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble_0_9_0 eint1, uint eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble_0_9_0 eint1, uint eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble_0_9_0 eint1, int eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble_0_9_0 eint1, int eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble_0_9_0 eint1, int eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble_0_9_0 eint1, int eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble_0_9_0 eint1, ushort eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble_0_9_0 eint1, ushort eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble_0_9_0 eint1, ushort eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble_0_9_0 eint1, ushort eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble_0_9_0 eint1, short eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble_0_9_0 eint1, short eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble_0_9_0 eint1, short eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble_0_9_0 eint1, short eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble_0_9_0 eint1, byte eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble_0_9_0 eint1, byte eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble_0_9_0 eint1, byte eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble_0_9_0 eint1, byte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble_0_9_0 eint1, sbyte eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble_0_9_0 eint1, sbyte eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble_0_9_0 eint1, sbyte eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble_0_9_0 eint1, sbyte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble_0_9_0 eint1, decimal eint2) => (decimal)eint1.Value == eint2; + public static bool operator !=(EncDouble_0_9_0 eint1, decimal eint2) => (decimal)eint1.Value != eint2; + public static bool operator >(EncDouble_0_9_0 eint1, decimal eint2) => (decimal)eint1.Value > eint2; + public static bool operator <(EncDouble_0_9_0 eint1, decimal eint2) => (decimal)eint1.Value < eint2; + + public static bool operator ==(EncDouble_0_9_0 eint1, double eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble_0_9_0 eint1, double eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble_0_9_0 eint1, double eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble_0_9_0 eint1, double eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble_0_9_0 eint1, float eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble_0_9_0 eint1, float eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble_0_9_0 eint1, float eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble_0_9_0 eint1, float eint2) => eint1.Value < eint2; + + /// assign + public static implicit operator EncDouble_0_9_0(double value) => new EncDouble_0_9_0(value); + public static explicit operator decimal(EncDouble_0_9_0 eint1) => (decimal)eint1.Value; + public static implicit operator double(EncDouble_0_9_0 eint1) => eint1.Value; + public static explicit operator float(EncDouble_0_9_0 eint1) => (float)eint1.Value; + public static explicit operator ulong(EncDouble_0_9_0 eint1) => (ulong)eint1.Value; + public static explicit operator long(EncDouble_0_9_0 eint1) => (long)eint1.Value; + public static explicit operator uint(EncDouble_0_9_0 eint1) => (uint)eint1.Value; + public static explicit operator int(EncDouble_0_9_0 eint1) => (int)eint1.Value; + public static explicit operator ushort(EncDouble_0_9_0 eint1) => (ushort)eint1.Value; + public static explicit operator short(EncDouble_0_9_0 eint1) => (short)eint1.Value; + public static explicit operator byte(EncDouble_0_9_0 eint1) => (byte)eint1.Value; + public static explicit operator sbyte(EncDouble_0_9_0 eint1) => (sbyte)eint1.Value; + + #endregion +} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_3_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_3_0.cs new file mode 100644 index 0000000..e728105 --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_3_0.cs @@ -0,0 +1,133 @@ +using System; + +public struct EncLong_0_3_0 +{ + /// A struct for storing a 64-bit integer while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as a long. + /// + /// Wiki page: https://github.com/JosepeDev/Variable-Encryption/wiki + /// Examples and tutorial: https://github.com/JosepeDev/Variable-Encryption/wiki/Examples-&-Tutorial + + #region Content + + #region Variables + + // The encryption values + private decimal encryptionKey1; + private decimal encryptionKey2; + + // The encrypted value stored in memory + private decimal encryptedValue; + + // The decrypted value + private decimal Value + { + set + { + encryptedValue = encrypt(value); + } + get + { + return Math.Round(decrypt(encryptedValue)); + } + } + + #endregion + + #region Constructors + + private EncLong_0_3_0(long value) + { + // set default values + encryptionKey1 = 0; + encryptionKey2 = 0; + encryptedValue = 0; + + // initialize + SetEncryptionKeys(); + encryptedValue = encrypt(value); + } + + #endregion + + #region Methods + + // Takes a given value and returns it encrypted + private decimal encrypt(decimal value) + { + decimal valueToReturn = value; + valueToReturn += encryptionKey1; + valueToReturn *= encryptionKey2; + return valueToReturn; + } + + // Takes an encrypted value and returns it decrypted + private decimal decrypt(decimal value) + { + decimal valueToReturn = value; + valueToReturn /= encryptionKey2; + valueToReturn -= encryptionKey1; + return valueToReturn; + } + + // Setting the encryption keys to a new random values + private void SetEncryptionKeys() + { + encryptionKey1 = EncryptionTools_0_3_0.RandomNumberDecimal(); + encryptionKey2 = EncryptionTools_0_3_0.RandomNumberDecimal(); + } + + // Returns the stored value as a string + public override string ToString() + { + return ((long)Value).ToString(); + } + + // Not recommended to use + public override bool Equals(object obj) + { + return obj is EncLong_0_3_0 eint && + (long)Value == (long)eint.Value; + } + public override int GetHashCode() + { + return (int)Value; + } + + #endregion + + #region Operators Overloading + + /// + - * / % + public static EncLong_0_3_0 operator +(EncLong_0_3_0 eint1, EncLong_0_3_0 eint2) => new EncLong_0_3_0((long)(eint1.Value + eint2.Value)); + public static EncLong_0_3_0 operator -(EncLong_0_3_0 eint1, EncLong_0_3_0 eint2) => new EncLong_0_3_0((long)(eint1.Value - eint2.Value)); + public static EncLong_0_3_0 operator *(EncLong_0_3_0 eint1, EncLong_0_3_0 eint2) => new EncLong_0_3_0((long)(eint1.Value * eint2.Value)); + public static EncLong_0_3_0 operator /(EncLong_0_3_0 eint1, EncLong_0_3_0 eint2) => new EncLong_0_3_0((long)(eint1.Value / eint2.Value)); + public static EncLong_0_3_0 operator %(EncLong_0_3_0 eint1, EncLong_0_3_0 eint2) => new EncLong_0_3_0((long)(eint1.Value % eint2.Value)); + + public static long operator +(EncLong_0_3_0 eint1, long eint2) => (long)eint1.Value + eint2; + public static long operator -(EncLong_0_3_0 eint1, long eint2) => (long)eint1.Value - eint2; + public static long operator *(EncLong_0_3_0 eint1, long eint2) => (long)eint1.Value * eint2; + public static long operator /(EncLong_0_3_0 eint1, long eint2) => (long)eint1.Value / eint2; + public static long operator %(EncLong_0_3_0 eint1, long eint2) => (long)eint1.Value % eint2; + + /// == != < > + public static bool operator ==(EncLong_0_3_0 eint1, long eint2) => (long)eint1.Value == eint2; + public static bool operator !=(EncLong_0_3_0 eint1, long eint2) => (long)eint1.Value != eint2; + public static bool operator >(EncLong_0_3_0 eint1, long eint2) => (long)eint1.Value > eint2; + public static bool operator <(EncLong_0_3_0 eint1, long eint2) => (long)eint1.Value < eint2; + + public static bool operator ==(EncLong_0_3_0 eint1, EncLong_0_3_0 eint2) => (long)eint1.Value == (long)eint2.Value; + public static bool operator !=(EncLong_0_3_0 eint1, EncLong_0_3_0 eint2) => (long)eint1.Value != (long)eint2.Value; + public static bool operator <(EncLong_0_3_0 eint1, EncLong_0_3_0 eint2) => (long)eint1.Value < (long)eint2.Value; + public static bool operator >(EncLong_0_3_0 eint1, EncLong_0_3_0 eint2) => (long)eint1.Value > (long)eint2.Value; + + /// assign + public static implicit operator EncLong_0_3_0(long value) => new EncLong_0_3_0(value); + public static implicit operator long(EncLong_0_3_0 eint1) => (long)eint1.Value; + + #endregion + + #endregion +} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_7_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_7_0.cs new file mode 100644 index 0000000..d404e5d --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_7_0.cs @@ -0,0 +1,196 @@ +using System; + +public struct EncLong_0_7_0 +{ + /// A struct for storing a 64-bit integer while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an long. + /// + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + + #region Variables And Properties + + // The encryption values + private decimal encryptionKey1; + private decimal encryptionKey2; + + // The encrypted value stored in memory + private decimal encryptedValue; + + // The decrypted value + private decimal Value + { + set + { + encryptedValue = Encrypt(value); + } + get + { + return Math.Round(Decrypt(encryptedValue)); + } + } + + public long MaxValue { get => Int64.MaxValue; } + public long MinValue { get => Int64.MinValue; } + + #endregion + + #region Methods + + private static EncLong_0_7_0 NewEncLong(long value) + { + EncLong_0_7_0 theEncLong = new EncLong_0_7_0 + { + encryptionKey1 = GetEncryptionKey(), + encryptionKey2 = GetEncryptionKey(), + Value = value + }; + return theEncLong; + } + + // Encryption Key Generator + static private Random random = new Random(); + static private decimal GetEncryptionKey() => (decimal)(random.NextDouble() * 10); + + // Takes a given value and returns it encrypted + private decimal Encrypt(decimal value) + { + decimal valueToReturn = value; + valueToReturn += encryptionKey1; + valueToReturn *= encryptionKey2; + return valueToReturn; + } + + // Takes an encrypted value and returns it decrypted + private decimal Decrypt(decimal value) + { + decimal valueToReturn = value; + valueToReturn /= encryptionKey2; + valueToReturn -= encryptionKey1; + return valueToReturn; + } + + // Int64 methods + public int CompareTo(object value) => ((long)Value).CompareTo(value); + public int CompareTo(long value) => ((long)Value).CompareTo(value); + public bool Equals(long obj) => ((long)Value).Equals(obj); + public override bool Equals(object obj) => ((long)Value).Equals(obj); + public override int GetHashCode() => ((long)Value).GetHashCode(); + public TypeCode GetTypeCode() => ((long)Value).GetTypeCode(); + public override string ToString() => ((long)Value).ToString(); + public string ToString(IFormatProvider provider) => ((long)Value).ToString(provider); + public string ToString(string format) => ((long)Value).ToString(format); + public string ToString(string format, IFormatProvider provider) => ((long)Value).ToString(format, provider); + + #endregion + + #region Operators Overloading + + /// + - * / % + public static EncLong_0_7_0 operator +(EncLong_0_7_0 elong1, EncLong_0_7_0 elong2) => EncLong_0_7_0.NewEncLong((long)(elong1.Value + elong2.Value)); + public static EncLong_0_7_0 operator -(EncLong_0_7_0 elong1, EncLong_0_7_0 elong2) => EncLong_0_7_0.NewEncLong((long)(elong1.Value - elong2.Value)); + public static EncLong_0_7_0 operator *(EncLong_0_7_0 elong1, EncLong_0_7_0 elong2) => EncLong_0_7_0.NewEncLong((long)(elong1.Value * elong2.Value)); + public static EncLong_0_7_0 operator /(EncLong_0_7_0 elong1, EncLong_0_7_0 elong2) => EncLong_0_7_0.NewEncLong((long)(elong1.Value / elong2.Value)); + public static EncLong_0_7_0 operator %(EncLong_0_7_0 elong1, EncLong_0_7_0 elong2) => EncLong_0_7_0.NewEncLong((long)(elong1.Value % elong2.Value)); + + public static long operator +(EncLong_0_7_0 elong1, long elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_7_0 elong1, long elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_7_0 elong1, long elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_7_0 elong1, long elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_7_0 elong1, long elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_7_0 elong1, int elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_7_0 elong1, int elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_7_0 elong1, int elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_7_0 elong1, int elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_7_0 elong1, int elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_7_0 elong1, short elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_7_0 elong1, short elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_7_0 elong1, short elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_7_0 elong1, short elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_7_0 elong1, short elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_7_0 elong1, ushort elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_7_0 elong1, ushort elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_7_0 elong1, ushort elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_7_0 elong1, ushort elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_7_0 elong1, ushort elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_7_0 elong1, uint elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_7_0 elong1, uint elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_7_0 elong1, uint elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_7_0 elong1, uint elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_7_0 elong1, uint elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_7_0 elong1, byte elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_7_0 elong1, byte elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_7_0 elong1, byte elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_7_0 elong1, byte elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_7_0 elong1, byte elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_7_0 elong1, sbyte elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_7_0 elong1, sbyte elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_7_0 elong1, sbyte elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_7_0 elong1, sbyte elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_7_0 elong1, sbyte elong2) => (long)elong1.Value % elong2; + + /// == != < > + /// + + public static bool operator ==(EncLong_0_7_0 elong1, byte elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_7_0 elong1, byte elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_7_0 elong1, byte elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_7_0 elong1, byte elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_7_0 elong1, sbyte elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_7_0 elong1, sbyte elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_7_0 elong1, sbyte elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_7_0 elong1, sbyte elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_7_0 elong1, short elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_7_0 elong1, short elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_7_0 elong1, short elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_7_0 elong1, short elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_7_0 elong1, ushort elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_7_0 elong1, ushort elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_7_0 elong1, ushort elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_7_0 elong1, ushort elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_7_0 elong1, uint elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_7_0 elong1, uint elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_7_0 elong1, uint elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_7_0 elong1, uint elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_7_0 elong1, int elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_7_0 elong1, int elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_7_0 elong1, int elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_7_0 elong1, int elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_7_0 elong1, long elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_7_0 elong1, long elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_7_0 elong1, long elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_7_0 elong1, long elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_7_0 elong1, EncLong_0_7_0 elong2) => (long)elong1.Value == (long)elong2.Value; + public static bool operator !=(EncLong_0_7_0 elong1, EncLong_0_7_0 elong2) => (long)elong1.Value != (long)elong2.Value; + public static bool operator <(EncLong_0_7_0 elong1, EncLong_0_7_0 elong2) => (long)elong1.Value < (long)elong2.Value; + public static bool operator >(EncLong_0_7_0 elong1, EncLong_0_7_0 elong2) => (long)elong1.Value > (long)elong2.Value; + + /// assign + public static implicit operator EncLong_0_7_0(long value) => EncLong_0_7_0.NewEncLong(value); + public static explicit operator ulong(EncLong_0_7_0 elong1) => (ulong)elong1.Value; + public static implicit operator long(EncLong_0_7_0 elong1) => (long)elong1.Value; + public static explicit operator uint(EncLong_0_7_0 elong1) => (uint)elong1.Value; + public static explicit operator int(EncLong_0_7_0 elong1) => (int)elong1.Value; + public static explicit operator ushort(EncLong_0_7_0 elong1) => (ushort)elong1.Value; + public static explicit operator short(EncLong_0_7_0 elong1) => (short)elong1.Value; + public static explicit operator byte(EncLong_0_7_0 elong1) => (byte)elong1.Value; + public static explicit operator sbyte(EncLong_0_7_0 elong1) => (sbyte)elong1.Value; + public static explicit operator decimal(EncLong_0_7_0 elong1) => elong1.Value; + public static explicit operator double(EncLong_0_7_0 elong1) => (double)elong1.Value; + public static explicit operator float(EncLong_0_7_0 elong1) => (float)elong1.Value; + + #endregion +} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_8_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_8_0.cs new file mode 100644 index 0000000..d1f9d78 --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_8_0.cs @@ -0,0 +1,193 @@ +using System; + +public struct EncLong_0_8_0 +{ + /// A struct for storing a 64-bit integer while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an long. + /// + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + + #region Variables And Properties + + // The encryption values + private decimal encryptionKey1; + private decimal encryptionKey2; + + // The encrypted value stored in memory + private decimal encryptedValue; + + // The decrypted value + private decimal Value + { + set + { + encryptedValue = Encrypt(value); + } + get + { + return Math.Round(Decrypt(encryptedValue)); + } + } + + public long MaxValue { get => Int64.MaxValue; } + public long MinValue { get => Int64.MinValue; } + + #endregion + + #region Methods & Constructors + + private EncLong_0_8_0(long value) + { + encryptionKey1 = GetEncryptionKey(); + encryptionKey2 = GetEncryptionKey(); + encryptedValue = 0; + Value = value; + } + + // Encryption Key Generator + static private Random random = new Random(); + static private decimal GetEncryptionKey() => (decimal)(random.NextDouble() * 10); + + // Takes a given value and returns it encrypted + private decimal Encrypt(decimal value) + { + decimal valueToReturn = value; + valueToReturn += encryptionKey1; + valueToReturn *= encryptionKey2; + return valueToReturn; + } + + // Takes an encrypted value and returns it decrypted + private decimal Decrypt(decimal value) + { + decimal valueToReturn = value; + valueToReturn /= encryptionKey2; + valueToReturn -= encryptionKey1; + return valueToReturn; + } + + // Int64 methods + public int CompareTo(object value) => ((long)Value).CompareTo(value); + public int CompareTo(long value) => ((long)Value).CompareTo(value); + public bool Equals(long obj) => ((long)Value).Equals(obj); + public override bool Equals(object obj) => ((long)Value).Equals(obj); + public override int GetHashCode() => ((long)Value).GetHashCode(); + public TypeCode GetTypeCode() => ((long)Value).GetTypeCode(); + public override string ToString() => ((long)Value).ToString(); + public string ToString(IFormatProvider provider) => ((long)Value).ToString(provider); + public string ToString(string format) => ((long)Value).ToString(format); + public string ToString(string format, IFormatProvider provider) => ((long)Value).ToString(format, provider); + + #endregion + + #region Operators Overloading + + /// + - * / % + public static EncLong_0_8_0 operator +(EncLong_0_8_0 elong1, EncLong_0_8_0 elong2) => new EncLong_0_8_0((long)(elong1.Value + elong2.Value)); + public static EncLong_0_8_0 operator -(EncLong_0_8_0 elong1, EncLong_0_8_0 elong2) => new EncLong_0_8_0((long)(elong1.Value - elong2.Value)); + public static EncLong_0_8_0 operator *(EncLong_0_8_0 elong1, EncLong_0_8_0 elong2) => new EncLong_0_8_0((long)(elong1.Value * elong2.Value)); + public static EncLong_0_8_0 operator /(EncLong_0_8_0 elong1, EncLong_0_8_0 elong2) => new EncLong_0_8_0((long)(elong1.Value / elong2.Value)); + public static EncLong_0_8_0 operator %(EncLong_0_8_0 elong1, EncLong_0_8_0 elong2) => new EncLong_0_8_0((long)(elong1.Value % elong2.Value)); + + public static long operator +(EncLong_0_8_0 elong1, long elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_8_0 elong1, long elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_8_0 elong1, long elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_8_0 elong1, long elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_8_0 elong1, long elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_8_0 elong1, int elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_8_0 elong1, int elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_8_0 elong1, int elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_8_0 elong1, int elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_8_0 elong1, int elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_8_0 elong1, short elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_8_0 elong1, short elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_8_0 elong1, short elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_8_0 elong1, short elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_8_0 elong1, short elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_8_0 elong1, ushort elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_8_0 elong1, ushort elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_8_0 elong1, ushort elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_8_0 elong1, ushort elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_8_0 elong1, ushort elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_8_0 elong1, uint elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_8_0 elong1, uint elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_8_0 elong1, uint elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_8_0 elong1, uint elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_8_0 elong1, uint elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_8_0 elong1, byte elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_8_0 elong1, byte elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_8_0 elong1, byte elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_8_0 elong1, byte elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_8_0 elong1, byte elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_8_0 elong1, sbyte elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_8_0 elong1, sbyte elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_8_0 elong1, sbyte elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_8_0 elong1, sbyte elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_8_0 elong1, sbyte elong2) => (long)elong1.Value % elong2; + + /// == != < > + /// + + public static bool operator ==(EncLong_0_8_0 elong1, byte elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_8_0 elong1, byte elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_8_0 elong1, byte elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_8_0 elong1, byte elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_8_0 elong1, sbyte elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_8_0 elong1, sbyte elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_8_0 elong1, sbyte elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_8_0 elong1, sbyte elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_8_0 elong1, short elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_8_0 elong1, short elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_8_0 elong1, short elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_8_0 elong1, short elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_8_0 elong1, ushort elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_8_0 elong1, ushort elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_8_0 elong1, ushort elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_8_0 elong1, ushort elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_8_0 elong1, uint elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_8_0 elong1, uint elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_8_0 elong1, uint elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_8_0 elong1, uint elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_8_0 elong1, int elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_8_0 elong1, int elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_8_0 elong1, int elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_8_0 elong1, int elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_8_0 elong1, long elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_8_0 elong1, long elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_8_0 elong1, long elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_8_0 elong1, long elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_8_0 elong1, EncLong_0_8_0 elong2) => (long)elong1.Value == (long)elong2.Value; + public static bool operator !=(EncLong_0_8_0 elong1, EncLong_0_8_0 elong2) => (long)elong1.Value != (long)elong2.Value; + public static bool operator <(EncLong_0_8_0 elong1, EncLong_0_8_0 elong2) => (long)elong1.Value < (long)elong2.Value; + public static bool operator >(EncLong_0_8_0 elong1, EncLong_0_8_0 elong2) => (long)elong1.Value > (long)elong2.Value; + + /// assign + public static implicit operator EncLong_0_8_0(long value) => new EncLong_0_8_0(value); + public static explicit operator ulong(EncLong_0_8_0 elong1) => (ulong)elong1.Value; + public static implicit operator long(EncLong_0_8_0 elong1) => (long)elong1.Value; + public static explicit operator uint(EncLong_0_8_0 elong1) => (uint)elong1.Value; + public static explicit operator int(EncLong_0_8_0 elong1) => (int)elong1.Value; + public static explicit operator ushort(EncLong_0_8_0 elong1) => (ushort)elong1.Value; + public static explicit operator short(EncLong_0_8_0 elong1) => (short)elong1.Value; + public static explicit operator byte(EncLong_0_8_0 elong1) => (byte)elong1.Value; + public static explicit operator sbyte(EncLong_0_8_0 elong1) => (sbyte)elong1.Value; + public static explicit operator decimal(EncLong_0_8_0 elong1) => elong1.Value; + public static explicit operator double(EncLong_0_8_0 elong1) => (double)elong1.Value; + public static explicit operator float(EncLong_0_8_0 elong1) => (float)elong1.Value; + + #endregion +} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_9_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_9_0.cs new file mode 100644 index 0000000..93bb532 --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_9_0.cs @@ -0,0 +1,172 @@ +using System; + +public struct EncLong_0_9_0 +{ + /// A struct for storing a 64-bit integer while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an long. + /// + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + + #region Variables And Properties + + // The encryption values + private readonly decimal encryptionKey1; + private readonly decimal encryptionKey2; + + // The encrypted value stored in memory + private readonly decimal encryptedValue; + + // The decrypted value + private decimal Value + { + get => Math.Round(Decrypt()); + } + + public long MaxValue { get => Int64.MaxValue; } + public long MinValue { get => Int64.MinValue; } + + #endregion + + #region Methods & Constructors + + private EncLong_0_9_0(decimal value) + { + encryptionKey1 = (decimal)random.NextDouble(); + encryptionKey2 = (decimal)random.NextDouble(); + encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + } + + // Encryption Key Generator + static private Random random = new Random(); + + // Takes a given value and returns it encrypted + private static decimal Encrypt(decimal value, decimal k1, decimal k2) => (value + k1) * k2; + + // Takes an encrypted value and returns it decrypted + private decimal Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + + // Int64 methods + public int CompareTo(object value) => ((long)Value).CompareTo(value); + public int CompareTo(long value) => ((long)Value).CompareTo(value); + public bool Equals(long obj) => ((long)Value).Equals(obj); + public override bool Equals(object obj) => ((long)Value).Equals(obj); + public override int GetHashCode() => ((long)Value).GetHashCode(); + public TypeCode GetTypeCode() => ((long)Value).GetTypeCode(); + public override string ToString() => ((long)Value).ToString(); + public string ToString(IFormatProvider provider) => ((long)Value).ToString(provider); + public string ToString(string format) => ((long)Value).ToString(format); + public string ToString(string format, IFormatProvider provider) => ((long)Value).ToString(format, provider); + + #endregion + + #region Operators Overloading + + /// + - * / % + public static EncLong_0_9_0 operator +(EncLong_0_9_0 elong1, EncLong_0_9_0 elong2) => new EncLong_0_9_0(Math.Round(elong1.Decrypt() + elong2.Decrypt())); + public static EncLong_0_9_0 operator -(EncLong_0_9_0 elong1, EncLong_0_9_0 elong2) => new EncLong_0_9_0(Math.Round(elong1.Decrypt() - elong2.Decrypt())); + public static EncLong_0_9_0 operator *(EncLong_0_9_0 elong1, EncLong_0_9_0 elong2) => new EncLong_0_9_0(Math.Round(elong1.Decrypt() * elong2.Decrypt())); + public static EncLong_0_9_0 operator /(EncLong_0_9_0 elong1, EncLong_0_9_0 elong2) => new EncLong_0_9_0(Math.Round(elong1.Decrypt() / elong2.Decrypt())); + public static EncLong_0_9_0 operator %(EncLong_0_9_0 elong1, EncLong_0_9_0 elong2) => new EncLong_0_9_0(Math.Round(elong1.Decrypt() % elong2.Decrypt())); + + public static long operator +(EncLong_0_9_0 elong1, long elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_9_0 elong1, long elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_9_0 elong1, long elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_9_0 elong1, long elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_9_0 elong1, long elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_9_0 elong1, int elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_9_0 elong1, int elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_9_0 elong1, int elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_9_0 elong1, int elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_9_0 elong1, int elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_9_0 elong1, short elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_9_0 elong1, short elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_9_0 elong1, short elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_9_0 elong1, short elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_9_0 elong1, short elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_9_0 elong1, ushort elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_9_0 elong1, ushort elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_9_0 elong1, ushort elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_9_0 elong1, ushort elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_9_0 elong1, ushort elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_9_0 elong1, uint elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_9_0 elong1, uint elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_9_0 elong1, uint elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_9_0 elong1, uint elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_9_0 elong1, uint elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_9_0 elong1, byte elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_9_0 elong1, byte elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_9_0 elong1, byte elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_9_0 elong1, byte elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_9_0 elong1, byte elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong_0_9_0 elong1, sbyte elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong_0_9_0 elong1, sbyte elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong_0_9_0 elong1, sbyte elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong_0_9_0 elong1, sbyte elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong_0_9_0 elong1, sbyte elong2) => (long)elong1.Value % elong2; + + /// == != < > + /// + + public static bool operator ==(EncLong_0_9_0 elong1, byte elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_9_0 elong1, byte elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_9_0 elong1, byte elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_9_0 elong1, byte elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_9_0 elong1, sbyte elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_9_0 elong1, sbyte elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_9_0 elong1, sbyte elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_9_0 elong1, sbyte elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_9_0 elong1, short elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_9_0 elong1, short elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_9_0 elong1, short elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_9_0 elong1, short elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_9_0 elong1, ushort elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_9_0 elong1, ushort elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_9_0 elong1, ushort elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_9_0 elong1, ushort elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_9_0 elong1, uint elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_9_0 elong1, uint elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_9_0 elong1, uint elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_9_0 elong1, uint elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_9_0 elong1, int elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_9_0 elong1, int elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_9_0 elong1, int elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_9_0 elong1, int elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_9_0 elong1, long elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong_0_9_0 elong1, long elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong_0_9_0 elong1, long elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong_0_9_0 elong1, long elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong_0_9_0 elong1, EncLong_0_9_0 elong2) => (long)elong1.Value == (long)elong2.Value; + public static bool operator !=(EncLong_0_9_0 elong1, EncLong_0_9_0 elong2) => (long)elong1.Value != (long)elong2.Value; + public static bool operator <(EncLong_0_9_0 elong1, EncLong_0_9_0 elong2) => (long)elong1.Value < (long)elong2.Value; + public static bool operator >(EncLong_0_9_0 elong1, EncLong_0_9_0 elong2) => (long)elong1.Value > (long)elong2.Value; + + /// assign + public static implicit operator EncLong_0_9_0(long value) => new EncLong_0_9_0(value); + public static explicit operator ulong(EncLong_0_9_0 elong1) => (ulong)elong1.Value; + public static implicit operator long(EncLong_0_9_0 elong1) => (long)elong1.Value; + public static explicit operator uint(EncLong_0_9_0 elong1) => (uint)elong1.Value; + public static explicit operator int(EncLong_0_9_0 elong1) => (int)elong1.Value; + public static explicit operator ushort(EncLong_0_9_0 elong1) => (ushort)elong1.Value; + public static explicit operator short(EncLong_0_9_0 elong1) => (short)elong1.Value; + public static explicit operator byte(EncLong_0_9_0 elong1) => (byte)elong1.Value; + public static explicit operator sbyte(EncLong_0_9_0 elong1) => (sbyte)elong1.Value; + public static explicit operator decimal(EncLong_0_9_0 elong1) => elong1.Value; + public static explicit operator double(EncLong_0_9_0 elong1) => (double)elong1.Value; + public static explicit operator float(EncLong_0_9_0 elong1) => (float)elong1.Value; + + #endregion +} \ No newline at end of file From 3f0aebb320647f79c3fc85a5d33a403348cf2636 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 06:03:37 +0200 Subject: [PATCH 16/53] Benchmark Improved - Now the comparisons are separated by their category in the menu. - Now a benchmark that compares strings will be faster. --- .../Benchmark/BenchmarkData.cs | 4 +- .../Benchmark/BenchmarksManager.cs | 59 ++++++++---- .../Benchmark/MenuSystem.cs | 32 ++++--- .../Benchmark/TestLibrary.cs | 93 ++++++++++++++++++- 4 files changed, 155 insertions(+), 33 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs index 88266f9..2f86358 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs @@ -26,7 +26,7 @@ public bool ComparingStrings if (benchmark1 == null || benchmark2 == null) return false; else { - return + return benchmark1.typeName.Contains("String") || benchmark2.typeName.Contains("String"); } @@ -58,7 +58,7 @@ public void InputPreset(BenchmarkPreset benchmarkPreset, string presetGroupName, { if (ComparingStrings) { - changesAmount = benchmarkPreset.ChangesAmount / 50; + changesAmount = benchmarkPreset.ChangesAmount / 100; } else { diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs index c671c64..bb65650 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs @@ -9,13 +9,13 @@ public static class BenchmarksManager { static BenchmarkResults currentBenchmarkResults; private static Stopwatch testsStopWatch; - + static public TypeInBenchmark[] benchmarkTypes = { new TypeInBenchmark("EncInt", WL_EncInt), // 0 - new TypeInBenchmark("int", WL_Int), + new TypeInBenchmark("int", WL_Int), new TypeInBenchmark("EncLong", WL_EncLong), // 2 - new TypeInBenchmark("long", WL_Long), + new TypeInBenchmark("long", WL_Long), new TypeInBenchmark("EncFloat", WL_EncFloat), // 4 new TypeInBenchmark("float", WL_Float), new TypeInBenchmark("EncDouble", WL_EncDouble), // 6 @@ -25,46 +25,69 @@ public static class BenchmarksManager new TypeInBenchmark("EncString", WL_EncString), // 10 new TypeInBenchmark("string", WL_String), new TypeInBenchmark("EncString (0.5.0)", WL_EncString_0_5_0), // 12 - new TypeInBenchmark("EncString (0.6.0)", WL_EncString_0_6_0), + new TypeInBenchmark("EncString (0.6.0)", WL_EncString_0_6_0), new TypeInBenchmark("EncInt (0.3.0)", WL_EncInt_0_3_0), // 14 new TypeInBenchmark("EncInt (0.7.0)", WL_EncInt_0_7_0), new TypeInBenchmark("EncInt (0.8.0)", WL_EncInt_0_8_0), // 16 - new TypeInBenchmark("EncDouble (0.5.0)", WL_EncDouble_0_5_0), + new TypeInBenchmark("EncDouble (0.5.0)", WL_EncDouble_0_5_0), new TypeInBenchmark("EncDouble (0.7.0)", WL_EncDouble_0_7_0), // 18 - new TypeInBenchmark("EncDouble (0.8.0)", WL_EncDouble_0_8_0), + new TypeInBenchmark("EncDouble (0.8.0)", WL_EncDouble_0_8_0), new TypeInBenchmark("EncString (0.8.0)", WL_EncString_0_8_0), // 20 - new TypeInBenchmark("EncInt (0.9.0)", WL_EncInt_0_9_0), + new TypeInBenchmark("EncInt (0.9.0)", WL_EncInt_0_9_0), new TypeInBenchmark("EncString (0.9.0)", WL_EncString_0_9_0), // 22 + new TypeInBenchmark("EncLong (0.3.0)", WL_EncLong_0_3_0), + new TypeInBenchmark("EncLong (0.7.0)", WL_EncLong_0_7_0), // 24 + new TypeInBenchmark("EncLong (0.8.0)", WL_EncLong_0_8_0), + new TypeInBenchmark("EncLong (0.9.0)", WL_EncLong_0_9_0), // 26 + new TypeInBenchmark("EncDecimal (0.5.0)", WL_EncDecimal_0_5_0), + new TypeInBenchmark("EncDecimal (0.7.0)", WL_EncDecimal_0_7_0), // 28 + new TypeInBenchmark("EncDecimal (0.8.0)", WL_EncDecimal_0_8_0), + new TypeInBenchmark("EncDecimal (0.9.0)", WL_EncDecimal_0_9_0), // 30 + new TypeInBenchmark("EncDouble (0.9.0)", WL_EncDouble_0_9_0), + }; static public BenchmarkData[] comparisons = { + // Enc vs normal + new BenchmarkData(benchmarkTypes[0], benchmarkTypes[1]), // int + new BenchmarkData(benchmarkTypes[2], benchmarkTypes[3]), // long + new BenchmarkData(benchmarkTypes[4], benchmarkTypes[5]), // float + new BenchmarkData(benchmarkTypes[6], benchmarkTypes[7]), // double + new BenchmarkData(benchmarkTypes[8], benchmarkTypes[9]), // decimal + new BenchmarkData(benchmarkTypes[10], benchmarkTypes[11]), // string + // EncInt - new BenchmarkData(benchmarkTypes[0], benchmarkTypes[1]), new BenchmarkData(benchmarkTypes[0], benchmarkTypes[14]), new BenchmarkData(benchmarkTypes[0], benchmarkTypes[15]), new BenchmarkData(benchmarkTypes[0], benchmarkTypes[16]), new BenchmarkData(benchmarkTypes[0], benchmarkTypes[21]), - new BenchmarkData(benchmarkTypes[2], benchmarkTypes[3]), // long - new BenchmarkData(benchmarkTypes[4], benchmarkTypes[5]), // float + // EncLong + new BenchmarkData(benchmarkTypes[2], benchmarkTypes[23]), + new BenchmarkData(benchmarkTypes[2], benchmarkTypes[24]), + new BenchmarkData(benchmarkTypes[2], benchmarkTypes[25]), + new BenchmarkData(benchmarkTypes[2], benchmarkTypes[26]), - // EncDouble - new BenchmarkData(benchmarkTypes[6], benchmarkTypes[7]), - new BenchmarkData(benchmarkTypes[6], benchmarkTypes[17]), - new BenchmarkData(benchmarkTypes[6], benchmarkTypes[18]), - new BenchmarkData(benchmarkTypes[6], benchmarkTypes[19]), - - new BenchmarkData(benchmarkTypes[8], benchmarkTypes[9]), // decimal + // EncDecimal + new BenchmarkData(benchmarkTypes[8], benchmarkTypes[27]), + new BenchmarkData(benchmarkTypes[8], benchmarkTypes[28]), + new BenchmarkData(benchmarkTypes[8], benchmarkTypes[29]), + new BenchmarkData(benchmarkTypes[8], benchmarkTypes[30]), // EncString - new BenchmarkData(benchmarkTypes[10], benchmarkTypes[11]), new BenchmarkData(benchmarkTypes[10], benchmarkTypes[12]), new BenchmarkData(benchmarkTypes[10], benchmarkTypes[13]), new BenchmarkData(benchmarkTypes[10], benchmarkTypes[20]), new BenchmarkData(benchmarkTypes[10], benchmarkTypes[22]), }; + static public int[] comparisonsChunks = + { + 6, 4, 4, 4, 4 + }; + + static BenchmarkPreset[] benchmarkPresetsFastest = { new BenchmarkPreset(20, 50000), diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs index 323f193..786660d 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs @@ -124,7 +124,7 @@ public static void DisplayBenchmarkPresetGroup(BenchmarkPresetGroup _group) int number = i + 1; int changesAmount = (currentBenchmarkData.ComparingStrings) - ? group.presets[i].ChangesAmount / 50 + ? group.presets[i].ChangesAmount / 100 : group.presets[i].ChangesAmount; string[] lines = @@ -160,18 +160,26 @@ public static void DisplayBenchmarkPresetGroupList() public static void DisplayComparisonsList() { - for (int i = 0; i < BenchmarksManager.comparisons.Length; i++) + int number = 0; + for (int i1 = 0; i1 < BenchmarksManager.comparisonsChunks.Length; i1++) { - int number = i + 1; - int currentL = BenchmarksManager.comparisons[i].benchmark1.typeName.Length; - string spaces1 = new string(' ', 3 - HowManyDigits(number)); - string spaces2 = new string(' ', GetTheSpacesLength() - currentL); - string line = string.Format( - "{0}." + spaces1 + "{1}" + spaces2 + "vs {2}", - number, BenchmarksManager.comparisons[i].benchmark1.typeName, - BenchmarksManager.comparisons[i].benchmark2.typeName); - - WriteLine(line); + for (int i2 = 0; i2 < BenchmarksManager.comparisonsChunks[i1]; i2++) + { + int currentL = BenchmarksManager.comparisons[number].benchmark1.typeName.Length; + string spaces1 = new string(' ', 3 - HowManyDigits(number + 1)); + string spaces2 = new string(' ', GetTheSpacesLength() - currentL); + string line = string.Format( + "{0}." + spaces1 + "{1}" + spaces2 + "vs {2}", + number + 1, BenchmarksManager.comparisons[number].benchmark1.typeName, + BenchmarksManager.comparisons[number].benchmark2.typeName); + WriteLine(line); + number++; + } + + if (i1 < BenchmarksManager.comparisonsChunks.Length - 1) + { + WriteLine(); + } } } diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs index cc2ae45..e5c6d28 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs @@ -92,6 +92,42 @@ public static void WL_EncLong(int amount) } } + public static void WL_EncLong_0_3_0(int amount) + { + EncLong_0_3_0 number1 = 0; + while (number1 < (long)amount) + { + number1++; + } + } + + public static void WL_EncLong_0_7_0(int amount) + { + EncLong_0_7_0 number1 = 0; + while (number1 < amount) + { + number1++; + } + } + + public static void WL_EncLong_0_8_0(int amount) + { + EncLong_0_8_0 number1 = 0; + while (number1 < amount) + { + number1++; + } + } + + public static void WL_EncLong_0_9_0(int amount) + { + EncLong_0_9_0 number1 = 0; + while (number1 < amount) + { + number1++; + } + } + public static void WL_Float(int amount) { float number1 = (float)RandomDouble(); @@ -124,7 +160,7 @@ public static void WL_Double(int amount) timesIncremented++; } } - + public static void WL_EncDouble(int amount) { EncDouble number1 = RandomDouble(); @@ -169,6 +205,17 @@ public static void WL_EncDouble_0_8_0(int amount) } } + public static void WL_EncDouble_0_9_0(int amount) + { + EncDouble_0_9_0 number1 = RandomDouble(); + int timesIncremented = 0; + while (timesIncremented < amount) + { + number1 += 0.46772781036222716d; + timesIncremented++; + } + } + public static void WL_Decimal(int amount) { decimal number1 = (decimal)RandomDouble() + 1.467727810362227164677278103622271646772781036222716m; @@ -191,6 +238,50 @@ public static void WL_EncDecimal(int amount) } } + public static void WL_EncDecimal_0_5_0(int amount) + { + EncDecimal_0_5_0 number1 = (decimal)RandomDouble() + 1.467727810362227164677278103622271646772781036222716m; + int timesIncremented = 0; + while (timesIncremented < amount) + { + number1 += 1.467727810362227164677278103622271646772781036222716m; + timesIncremented++; + } + } + + public static void WL_EncDecimal_0_7_0(int amount) + { + EncDecimal_0_7_0 number1 = (decimal)RandomDouble() + 1.467727810362227164677278103622271646772781036222716m; + int timesIncremented = 0; + while (timesIncremented < amount) + { + number1 += 1.467727810362227164677278103622271646772781036222716m; + timesIncremented++; + } + } + + public static void WL_EncDecimal_0_8_0(int amount) + { + EncDecimal_0_8_0 number1 = (decimal)RandomDouble() + 1.467727810362227164677278103622271646772781036222716m; + int timesIncremented = 0; + while (timesIncremented < amount) + { + number1 += 1.467727810362227164677278103622271646772781036222716m; + timesIncremented++; + } + } + + public static void WL_EncDecimal_0_9_0(int amount) + { + EncDecimal_0_9_0 number1 = (decimal)RandomDouble() + 1.467727810362227164677278103622271646772781036222716m; + int timesIncremented = 0; + while (timesIncremented < amount) + { + number1 += 1.467727810362227164677278103622271646772781036222716m; + timesIncremented++; + } + } + public static void WL_String(int amount) { string stringVar = RandomString(); From 938ca750292bbe7d770c1df83a88445de3655015 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 16:41:59 +0200 Subject: [PATCH 17/53] Update EncString.cs - Changed the encryption method --- .../Variable-Encryption/Types/EncString.cs | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs index 708ffb7..f69066c 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs @@ -12,8 +12,8 @@ public class EncString #region Variables And Properties - private readonly string _encryptionKey; - private readonly string _encryptedValue; + private readonly char[] _encryptionKeys; + private readonly char[] _encryptedValue; ///

/// The decrypted value of the stored string. @@ -125,8 +125,8 @@ public char this[int index] public EncString(string value) { - _encryptionKey = RandomString(); - _encryptedValue = Encrypt(value, _encryptionKey); + _encryptionKeys = EncKeys(); + _encryptedValue = Encrypt(value, _encryptionKeys); } public EncString(char[] value) @@ -145,17 +145,17 @@ public EncString(char[] value, int startIndex, int length) static Random random = new Random(); - static string RandomString() + static char[] EncKeys() { char[] chars = new char[random.Next(10, 100)]; // random length for (int i = 0; i < chars.Length; i++) { chars[i] = (char)(random.Next(char.MinValue, char.MinValue)); // random chars } - return new string(chars); + return chars; } - private static string Encrypt(string data, string key) + private static char[] Encrypt(string data, char[] key) { if (data == null) { @@ -172,7 +172,7 @@ private static string Encrypt(string data, string key) output[i] = (char)(data[i] ^ key[i % keyLen]); } - return new string(output); + return output; } } @@ -185,12 +185,12 @@ private string Decrypt() else { int dataLen = _encryptedValue.Length; - int keyLen = _encryptionKey.Length; + int keyLen = _encryptionKeys.Length; char[] output = new char[dataLen]; for (int i = 0; i < dataLen; ++i) { - output[i] = (char)(_encryptedValue[i] ^ _encryptionKey[i % keyLen]); + output[i] = (char)(_encryptedValue[i] ^ _encryptionKeys[i % keyLen]); } return new string(output); From 637756bb1c80969a9605fee6e5a6515f4077df7e Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 16:42:38 +0200 Subject: [PATCH 18/53] Update EncDouble.cs --- .../Variable-Encryption/Types/EncDouble.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs index 5a1a7ad..ee3102c 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs @@ -36,7 +36,6 @@ public double Value private EncDouble(double value) { encryptionKeys = new byte[8]; - random.NextBytes(encryptionKeys); encryptedValue = Encrypt(value, encryptionKeys); } @@ -46,6 +45,7 @@ private EncDouble(double value) // Takes a given value and returns it encrypted private static byte[] Encrypt(double value, byte[] keys) { + random.NextBytes(keys); var valueBytes = BitConverter.GetBytes(value); for (int i = 0; i < 8; i++) { From b3ba2de039304855d8c9ef80c46ddadb97526691 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 16:44:03 +0200 Subject: [PATCH 19/53] Old types - Removed unnecessary old types from the benchmark. - Added older versions of EncFloat --- .../OldTypes/EncDecimal_0_7_0.cs | 244 ------------------ .../OldTypes/EncDouble_0_7_0.cs | 237 ----------------- .../OldTypes/EncFloat_0_5_0.cs | 137 ++++++++++ .../OldTypes/EncFloat_0_8_0.cs | 239 +++++++++++++++++ .../OldTypes/EncFloat_0_9_0.cs | 207 +++++++++++++++ .../OldTypes/EncString_0_6_0.cs | 157 ----------- .../OldTypes/EncString_0_7_0.cs | 228 ++++++++++++++++ 7 files changed, 811 insertions(+), 638 deletions(-) delete mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_7_0.cs delete mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_7_0.cs create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_5_0.cs create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_8_0.cs create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_9_0.cs delete mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_6_0.cs create mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_7_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_7_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_7_0.cs deleted file mode 100644 index d143c3b..0000000 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_7_0.cs +++ /dev/null @@ -1,244 +0,0 @@ -using System; - -public struct EncDecimal_0_7_0 -{ - /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an deciaml. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc - - #region Variables And Properties - - // The encryption values - private decimal encryptionKey1; - private decimal encryptionKey2; - - // The encrypted value stored in memory - private decimal encryptedValue; - - // The decrypted value - public decimal Value - { - set - { - encryptedValue = Encrypt(value); - } - get - { - return (decimal)Decrypt(encryptedValue); - } - } - - public Decimal MaxValue { get => Decimal.MaxValue; } - public Decimal MinValue { get => Decimal.MinValue; } - public Decimal MinusOne { get => Decimal.MinusOne; } - public Decimal One { get => Decimal.One; } - public Decimal Zero { get => Decimal.Zero; } - - #endregion - - #region Methods - - private static EncDecimal_0_7_0 NewEncDecimal(decimal value) - { - EncDecimal_0_7_0 theEncdecimal = new EncDecimal_0_7_0 - { - encryptionKey1 = GetEncryptionKey(), - encryptionKey2 = GetEncryptionKey(), - Value = value - }; - return theEncdecimal; - } - - // Encryption key generator - static private Random random = new Random(); - static private decimal GetEncryptionKey() => (decimal)(random.NextDouble()); - - // Takes a given value and returns it encrypted - private decimal Encrypt(decimal value) - { - decimal valueToReturn = value; - valueToReturn += encryptionKey1; - valueToReturn *= encryptionKey2; - return valueToReturn; - } - - // Takes an encrypted value and returns it decrypted - private decimal Decrypt(decimal value) - { - decimal valueToReturn = value; - valueToReturn /= encryptionKey2; - valueToReturn -= encryptionKey1; - return valueToReturn; - } - - // Overrides - public int CompareTo(Decimal value) => Value.CompareTo(value); - public int CompareTo(object value) => Value.CompareTo(value); - public bool Equals(Decimal value) => Value.Equals(value); - public override bool Equals(object value) => Value.Equals(value); - public override int GetHashCode() => Value.GetHashCode(); - public TypeCode GetTypeCode() => Value.GetTypeCode(); - public string ToString(string format) => Value.ToString(format); - public string ToString(IFormatProvider provider) => Value.ToString(provider); - public override string ToString() => Value.ToString(); - public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); - - #endregion - - #region Operators Overloading - - /// + - * / % - - public static EncDecimal_0_7_0 operator +(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => EncDecimal_0_7_0.NewEncDecimal(eint1.Value + eint2.Value); - public static EncDecimal_0_7_0 operator -(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => EncDecimal_0_7_0.NewEncDecimal(eint1.Value - eint2.Value); - public static EncDecimal_0_7_0 operator *(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => EncDecimal_0_7_0.NewEncDecimal(eint1.Value * eint2.Value); - public static EncDecimal_0_7_0 operator /(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => EncDecimal_0_7_0.NewEncDecimal(eint1.Value / eint2.Value); - public static EncDecimal_0_7_0 operator %(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => EncDecimal_0_7_0.NewEncDecimal(eint1.Value % eint2.Value); - - public static decimal operator +(EncDecimal_0_7_0 edecimal1, ulong edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal_0_7_0 edecimal1, ulong edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal_0_7_0 edecimal1, ulong edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal_0_7_0 edecimal1, ulong edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal_0_7_0 edecimal1, ulong edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal_0_7_0 edecimal1, long edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal_0_7_0 edecimal1, long edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal_0_7_0 edecimal1, long edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal_0_7_0 edecimal1, long edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal_0_7_0 edecimal1, long edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal_0_7_0 edecimal1, uint edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal_0_7_0 edecimal1, uint edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal_0_7_0 edecimal1, uint edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal_0_7_0 edecimal1, uint edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal_0_7_0 edecimal1, uint edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal_0_7_0 edecimal1, int edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal_0_7_0 edecimal1, int edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal_0_7_0 edecimal1, int edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal_0_7_0 edecimal1, int edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal_0_7_0 edecimal1, int edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal_0_7_0 edecimal1, ushort edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal_0_7_0 edecimal1, ushort edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal_0_7_0 edecimal1, ushort edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal_0_7_0 edecimal1, ushort edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal_0_7_0 edecimal1, ushort edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal_0_7_0 edecimal1, short edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal_0_7_0 edecimal1, short edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal_0_7_0 edecimal1, short edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal_0_7_0 edecimal1, short edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal_0_7_0 edecimal1, short edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal_0_7_0 edecimal1, byte edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal_0_7_0 edecimal1, byte edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal_0_7_0 edecimal1, byte edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal_0_7_0 edecimal1, byte edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal_0_7_0 edecimal1, byte edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal_0_7_0 edecimal1, sbyte edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal_0_7_0 edecimal1, sbyte edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal_0_7_0 edecimal1, sbyte edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal_0_7_0 edecimal1, sbyte edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal_0_7_0 edecimal1, sbyte edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal_0_7_0 edecimal1, decimal edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal_0_7_0 edecimal1, decimal edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal_0_7_0 edecimal1, decimal edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal_0_7_0 edecimal1, decimal edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal_0_7_0 edecimal1, decimal edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal_0_7_0 edecimal1, double edecimal2) => edecimal1.Value + (decimal)edecimal2; - public static decimal operator -(EncDecimal_0_7_0 edecimal1, double edecimal2) => edecimal1.Value - (decimal)edecimal2; - public static decimal operator *(EncDecimal_0_7_0 edecimal1, double edecimal2) => edecimal1.Value * (decimal)edecimal2; - public static decimal operator /(EncDecimal_0_7_0 edecimal1, double edecimal2) => edecimal1.Value / (decimal)edecimal2; - public static decimal operator %(EncDecimal_0_7_0 edecimal1, double edecimal2) => edecimal1.Value % (decimal)edecimal2; - - public static decimal operator +(EncDecimal_0_7_0 edecimal1, float edecimal2) => edecimal1.Value + (decimal)edecimal2; - public static decimal operator -(EncDecimal_0_7_0 edecimal1, float edecimal2) => edecimal1.Value - (decimal)edecimal2; - public static decimal operator *(EncDecimal_0_7_0 edecimal1, float edecimal2) => edecimal1.Value * (decimal)edecimal2; - public static decimal operator /(EncDecimal_0_7_0 edecimal1, float edecimal2) => edecimal1.Value / (decimal)edecimal2; - public static decimal operator %(EncDecimal_0_7_0 edecimal1, float edecimal2) => edecimal1.Value % (decimal)edecimal2; - - /// == != < > - - public static bool operator ==(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => eint1.Value == eint2.Value; - public static bool operator !=(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => eint1.Value != eint2.Value; - public static bool operator <(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => eint1.Value < eint2.Value; - public static bool operator >(EncDecimal_0_7_0 eint1, EncDecimal_0_7_0 eint2) => eint1.Value > eint2.Value; - - public static bool operator ==(EncDecimal_0_7_0 eint1, ulong eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal_0_7_0 eint1, ulong eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal_0_7_0 eint1, ulong eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal_0_7_0 eint1, ulong eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal_0_7_0 eint1, long eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal_0_7_0 eint1, long eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal_0_7_0 eint1, long eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal_0_7_0 eint1, long eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal_0_7_0 eint1, uint eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal_0_7_0 eint1, uint eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal_0_7_0 eint1, uint eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal_0_7_0 eint1, uint eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal_0_7_0 eint1, int eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal_0_7_0 eint1, int eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal_0_7_0 eint1, int eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal_0_7_0 eint1, int eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal_0_7_0 eint1, ushort eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal_0_7_0 eint1, ushort eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal_0_7_0 eint1, ushort eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal_0_7_0 eint1, ushort eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal_0_7_0 eint1, short eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal_0_7_0 eint1, short eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal_0_7_0 eint1, short eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal_0_7_0 eint1, short eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal_0_7_0 eint1, byte eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal_0_7_0 eint1, byte eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal_0_7_0 eint1, byte eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal_0_7_0 eint1, byte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal_0_7_0 eint1, sbyte eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal_0_7_0 eint1, sbyte eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal_0_7_0 eint1, sbyte eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal_0_7_0 eint1, sbyte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal_0_7_0 eint1, decimal eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal_0_7_0 eint1, decimal eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal_0_7_0 eint1, decimal eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal_0_7_0 eint1, decimal eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal_0_7_0 eint1, double eint2) => eint1.Value == (decimal)eint2; - public static bool operator !=(EncDecimal_0_7_0 eint1, double eint2) => eint1.Value != (decimal)eint2; - public static bool operator >(EncDecimal_0_7_0 eint1, double eint2) => eint1.Value > (decimal)eint2; - public static bool operator <(EncDecimal_0_7_0 eint1, double eint2) => eint1.Value < (decimal)eint2; - - public static bool operator ==(EncDecimal_0_7_0 eint1, float eint2) => eint1.Value == (decimal)eint2; - public static bool operator !=(EncDecimal_0_7_0 eint1, float eint2) => eint1.Value != (decimal)eint2; - public static bool operator >(EncDecimal_0_7_0 eint1, float eint2) => eint1.Value > (decimal)eint2; - public static bool operator <(EncDecimal_0_7_0 eint1, float eint2) => eint1.Value < (decimal)eint2; - - /// assign - - public static implicit operator EncDecimal_0_7_0(decimal value) => EncDecimal_0_7_0.NewEncDecimal(value); - public static implicit operator decimal(EncDecimal_0_7_0 eint1) => eint1.Value; - public static explicit operator double(EncDecimal_0_7_0 eint1) => (double)eint1.Value; - public static explicit operator float(EncDecimal_0_7_0 eint1) => (float)eint1.Value; - public static explicit operator ulong(EncDecimal_0_7_0 eint1) => (ulong)eint1.Value; - public static explicit operator long(EncDecimal_0_7_0 eint1) => (long)eint1.Value; - public static explicit operator uint(EncDecimal_0_7_0 eint1) => (uint)eint1.Value; - public static explicit operator int(EncDecimal_0_7_0 eint1) => (int)eint1.Value; - public static explicit operator ushort(EncDecimal_0_7_0 eint1) => (ushort)eint1.Value; - public static explicit operator short(EncDecimal_0_7_0 eint1) => (short)eint1.Value; - public static explicit operator byte(EncDecimal_0_7_0 eint1) => (byte)eint1.Value; - public static explicit operator sbyte(EncDecimal_0_7_0 eint1) => (sbyte)eint1.Value; - - #endregion -} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_7_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_7_0.cs deleted file mode 100644 index 822d84b..0000000 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_7_0.cs +++ /dev/null @@ -1,237 +0,0 @@ -using System; - -public struct EncDouble_0_7_0 -{ - /// A struct for storing a Double while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an double. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc - - #region Variables And Properties - - // The encryption values - private double encryptionKey1; - private double encryptionKey2; - - // The encrypted value stored in memory - private double encryptedValue; - - // The decrypted value - public double Value - { - set - { - encryptedValue = Encrypt(value); - } - get - { - return Decrypt(encryptedValue); - } - } - - public Double Epsilon { get => Double.Epsilon; } - public Double MaxValue { get => Double.MaxValue; } - public Double MinValue { get => Double.MinValue; } - public Double NaN { get => Double.NaN; } - public Double NegativeInfinity { get => Double.NegativeInfinity; } - public Double PositiveInfinity { get => Double.PositiveInfinity; } - - #endregion - - #region Methods - - private static EncDouble_0_7_0 NewEncDouble(double value) - { - EncDouble_0_7_0 theEncFloat = new EncDouble_0_7_0 - { - encryptionKey1 = GetEncryptionKey(), - encryptionKey2 = GetEncryptionKey(), - Value = value - }; - return theEncFloat; - } - - // Encryption key generator - static private Random random = new Random(); - static private double GetEncryptionKey() => random.NextDouble(); - - // Takes a given value and returns it encrypted - private double Encrypt(double value) - { - double valueToReturn = value; - valueToReturn += encryptionKey1; - valueToReturn *= encryptionKey2; - return valueToReturn; - } - - // Takes an encrypted value and returns it decrypted - private double Decrypt(double value) - { - double valueToReturn = value; - valueToReturn /= encryptionKey2; - valueToReturn -= encryptionKey1; - return valueToReturn; - } - - // Overrides - public int CompareTo(object value) => Value.CompareTo(value); - public int CompareTo(Double value) => Value.CompareTo(value); - public bool Equals(Double obj) => Value.Equals(obj); - public override bool Equals(object obj) => Value.Equals(obj); - public override int GetHashCode() => Value.GetHashCode(); - public TypeCode GetTypeCode() => Value.GetTypeCode(); - public override string ToString() => Value.ToString(); - public string ToString(IFormatProvider provider) => Value.ToString(provider); - public string ToString(string format) => Value.ToString(format); - public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); - - #endregion - - #region Operators Overloading - - /// + - * / % - public static EncDouble_0_7_0 operator +(EncDouble_0_7_0 eint1, EncDouble_0_7_0 eint2) => EncDouble_0_7_0.NewEncDouble(eint1.Value + eint2.Value); - public static EncDouble_0_7_0 operator -(EncDouble_0_7_0 eint1, EncDouble_0_7_0 eint2) => EncDouble_0_7_0.NewEncDouble(eint1.Value - eint2.Value); - public static EncDouble_0_7_0 operator *(EncDouble_0_7_0 eint1, EncDouble_0_7_0 eint2) => EncDouble_0_7_0.NewEncDouble(eint1.Value * eint2.Value); - public static EncDouble_0_7_0 operator /(EncDouble_0_7_0 eint1, EncDouble_0_7_0 eint2) => EncDouble_0_7_0.NewEncDouble(eint1.Value / eint2.Value); - public static EncDouble_0_7_0 operator %(EncDouble_0_7_0 eint1, EncDouble_0_7_0 eint2) => EncDouble_0_7_0.NewEncDouble(eint1.Value % eint2.Value); - - public static double operator +(EncDouble_0_7_0 edouble1, ulong edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble_0_7_0 edouble1, ulong edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble_0_7_0 edouble1, ulong edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble_0_7_0 edouble1, ulong edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble_0_7_0 edouble1, ulong edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble_0_7_0 edouble1, long edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble_0_7_0 edouble1, long edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble_0_7_0 edouble1, long edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble_0_7_0 edouble1, long edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble_0_7_0 edouble1, long edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble_0_7_0 edouble1, uint edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble_0_7_0 edouble1, uint edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble_0_7_0 edouble1, uint edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble_0_7_0 edouble1, uint edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble_0_7_0 edouble1, uint edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble_0_7_0 edouble1, int edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble_0_7_0 edouble1, int edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble_0_7_0 edouble1, int edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble_0_7_0 edouble1, int edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble_0_7_0 edouble1, int edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble_0_7_0 edouble1, ushort edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble_0_7_0 edouble1, ushort edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble_0_7_0 edouble1, ushort edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble_0_7_0 edouble1, ushort edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble_0_7_0 edouble1, ushort edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble_0_7_0 edouble1, short edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble_0_7_0 edouble1, short edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble_0_7_0 edouble1, short edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble_0_7_0 edouble1, short edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble_0_7_0 edouble1, short edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble_0_7_0 edouble1, byte edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble_0_7_0 edouble1, byte edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble_0_7_0 edouble1, byte edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble_0_7_0 edouble1, byte edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble_0_7_0 edouble1, byte edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble_0_7_0 edouble1, sbyte edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble_0_7_0 edouble1, sbyte edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble_0_7_0 edouble1, sbyte edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble_0_7_0 edouble1, sbyte edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble_0_7_0 edouble1, sbyte edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble_0_7_0 edouble1, double edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble_0_7_0 edouble1, double edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble_0_7_0 edouble1, double edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble_0_7_0 edouble1, double edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble_0_7_0 edouble1, double edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble_0_7_0 edouble1, float edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble_0_7_0 edouble1, float edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble_0_7_0 edouble1, float edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble_0_7_0 edouble1, float edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble_0_7_0 edouble1, float edouble2) => edouble1.Value % edouble2; - - /// == != < > - - public static bool operator ==(EncDouble_0_7_0 eint1, EncDouble_0_7_0 eint2) => eint1.Value == eint2.Value; - public static bool operator !=(EncDouble_0_7_0 eint1, EncDouble_0_7_0 eint2) => eint1.Value != eint2.Value; - public static bool operator <(EncDouble_0_7_0 eint1, EncDouble_0_7_0 eint2) => eint1.Value < eint2.Value; - public static bool operator >(EncDouble_0_7_0 eint1, EncDouble_0_7_0 eint2) => eint1.Value > eint2.Value; - - public static bool operator ==(EncDouble_0_7_0 eint1, ulong eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble_0_7_0 eint1, ulong eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble_0_7_0 eint1, ulong eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble_0_7_0 eint1, ulong eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble_0_7_0 eint1, long eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble_0_7_0 eint1, long eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble_0_7_0 eint1, long eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble_0_7_0 eint1, long eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble_0_7_0 eint1, uint eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble_0_7_0 eint1, uint eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble_0_7_0 eint1, uint eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble_0_7_0 eint1, uint eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble_0_7_0 eint1, int eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble_0_7_0 eint1, int eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble_0_7_0 eint1, int eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble_0_7_0 eint1, int eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble_0_7_0 eint1, ushort eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble_0_7_0 eint1, ushort eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble_0_7_0 eint1, ushort eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble_0_7_0 eint1, ushort eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble_0_7_0 eint1, short eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble_0_7_0 eint1, short eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble_0_7_0 eint1, short eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble_0_7_0 eint1, short eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble_0_7_0 eint1, byte eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble_0_7_0 eint1, byte eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble_0_7_0 eint1, byte eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble_0_7_0 eint1, byte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble_0_7_0 eint1, sbyte eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble_0_7_0 eint1, sbyte eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble_0_7_0 eint1, sbyte eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble_0_7_0 eint1, sbyte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble_0_7_0 eint1, decimal eint2) => (decimal)eint1.Value == eint2; - public static bool operator !=(EncDouble_0_7_0 eint1, decimal eint2) => (decimal)eint1.Value != eint2; - public static bool operator >(EncDouble_0_7_0 eint1, decimal eint2) => (decimal)eint1.Value > eint2; - public static bool operator <(EncDouble_0_7_0 eint1, decimal eint2) => (decimal)eint1.Value < eint2; - - public static bool operator ==(EncDouble_0_7_0 eint1, double eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble_0_7_0 eint1, double eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble_0_7_0 eint1, double eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble_0_7_0 eint1, double eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble_0_7_0 eint1, float eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble_0_7_0 eint1, float eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble_0_7_0 eint1, float eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble_0_7_0 eint1, float eint2) => eint1.Value < eint2; - - /// assign - public static implicit operator EncDouble_0_7_0(double value) => EncDouble_0_7_0.NewEncDouble(value); - public static explicit operator decimal(EncDouble_0_7_0 eint1) => (decimal)eint1.Value; - public static implicit operator double(EncDouble_0_7_0 eint1) => eint1.Value; - public static explicit operator float(EncDouble_0_7_0 eint1) => (float)eint1.Value; - public static explicit operator ulong(EncDouble_0_7_0 eint1) => (ulong)eint1.Value; - public static explicit operator long(EncDouble_0_7_0 eint1) => (long)eint1.Value; - public static explicit operator uint(EncDouble_0_7_0 eint1) => (uint)eint1.Value; - public static explicit operator int(EncDouble_0_7_0 eint1) => (int)eint1.Value; - public static explicit operator ushort(EncDouble_0_7_0 eint1) => (ushort)eint1.Value; - public static explicit operator short(EncDouble_0_7_0 eint1) => (short)eint1.Value; - public static explicit operator byte(EncDouble_0_7_0 eint1) => (byte)eint1.Value; - public static explicit operator sbyte(EncDouble_0_7_0 eint1) => (sbyte)eint1.Value; - - #endregion -} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_5_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_5_0.cs new file mode 100644 index 0000000..a3d9f79 --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_5_0.cs @@ -0,0 +1,137 @@ +using System; + +public struct EncFloat_0_5_0 +{ + /// A struct for storing a Single while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an flaot. + /// + /// Wiki page: https://github.com/JosepeDev/Variable-Encryption/wiki + + #region Content + + #region Encryption Key Generator + + // The Random class for getting the random numbers + static private Random random = new Random(); + + // Returns a random double between 1 and 10 + public static double GetEncryptionKey() + { + return random.NextDouble(); + } + + #endregion + + #region Variables + + // The encryption values + private double encryptionKey1; + private double encryptionKey2; + + // The encrypted value stored in memory + private double encryptedValue; + + // The decrypted value + private float Value + { + set + { + encryptedValue = encrypt(value); + } + get + { + return (float)(decrypt(encryptedValue)); + } + } + + #endregion + + #region Constructors + + public static EncFloat_0_5_0 NewEncFloat(float value) + { + EncFloat_0_5_0 theEncFloat = new EncFloat_0_5_0 + { + encryptionKey1 = GetEncryptionKey(), + encryptionKey2 = GetEncryptionKey(), + Value = value + }; + return theEncFloat; + } + + #endregion + + #region Methods + + // Takes a given value and returns it encrypted + private double encrypt(double value) + { + double valueToReturn = value; + valueToReturn += encryptionKey1; + valueToReturn *= encryptionKey2; + return valueToReturn; + } + + // Takes an encrypted value and returns it decrypted + private double decrypt(double value) + { + double valueToReturn = value; + valueToReturn /= encryptionKey2; + valueToReturn -= encryptionKey1; + return valueToReturn; + } + + // Returns the stored value as a string + public override string ToString() + { + return (Value).ToString(); + } + + // Not recommended to use + public override bool Equals(object obj) + { + return obj is EncFloat_0_5_0 ecnFloat && + Value == ecnFloat.Value; + } + public override int GetHashCode() + { + return (int)Value; + } + + #endregion + + #region Operators Overloading + + /// + - * / % + public static EncFloat_0_5_0 operator +(EncFloat_0_5_0 eint1, EncFloat_0_5_0 eint2) => EncFloat_0_5_0.NewEncFloat(eint1.Value + eint2.Value); + public static EncFloat_0_5_0 operator -(EncFloat_0_5_0 eint1, EncFloat_0_5_0 eint2) => EncFloat_0_5_0.NewEncFloat(eint1.Value - eint2.Value); + public static EncFloat_0_5_0 operator *(EncFloat_0_5_0 eint1, EncFloat_0_5_0 eint2) => EncFloat_0_5_0.NewEncFloat(eint1.Value * eint2.Value); + public static EncFloat_0_5_0 operator /(EncFloat_0_5_0 eint1, EncFloat_0_5_0 eint2) => EncFloat_0_5_0.NewEncFloat(eint1.Value / eint2.Value); + public static EncFloat_0_5_0 operator %(EncFloat_0_5_0 eint1, EncFloat_0_5_0 eint2) => EncFloat_0_5_0.NewEncFloat(eint1.Value % eint2.Value); + + public static float operator +(EncFloat_0_5_0 efloat1, float efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_5_0 efloat1, float efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_5_0 efloat1, float efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_5_0 efloat1, float efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_5_0 efloat1, float efloat2) => efloat1.Value % efloat2; + + /// == != < > + public static bool operator ==(EncFloat_0_5_0 eint1, float eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_5_0 eint1, float eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_5_0 eint1, float eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_5_0 eint1, float eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_5_0 eint1, EncFloat_0_5_0 eint2) => eint1.Value == eint2.Value; + public static bool operator !=(EncFloat_0_5_0 eint1, EncFloat_0_5_0 eint2) => eint1.Value != eint2.Value; + public static bool operator <(EncFloat_0_5_0 eint1, EncFloat_0_5_0 eint2) => eint1.Value < eint2.Value; + public static bool operator >(EncFloat_0_5_0 eint1, EncFloat_0_5_0 eint2) => eint1.Value > eint2.Value; + + /// assign + public static implicit operator EncFloat_0_5_0(float value) => EncFloat_0_5_0.NewEncFloat(value); + public static implicit operator float(EncFloat_0_5_0 eint1) => eint1.Value; + + #endregion + + #endregion +} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_8_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_8_0.cs new file mode 100644 index 0000000..55eb9b9 --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_8_0.cs @@ -0,0 +1,239 @@ +using System; + +public struct EncFloat_0_8_0 +{ + /// A struct for storing a Single while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an flaot. + /// + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + + #region Variables And Properties + + // The encryption values + private double encryptionKey1; + private double encryptionKey2; + + // The encrypted value stored in memory + private double encryptedValue; + + // The decrypted value + private float Value + { + set + { + encryptedValue = Encrypt(value); + } + get + { + return (float)(Decrypt(encryptedValue)); + } + } + + public float Epsilon { get => Single.Epsilon; } + public float MaxValue { get => Single.MaxValue; } + public float MinValue { get => Single.MinValue; } + public float NaN { get => Single.NaN; } + public float NegativeInfinity { get => Single.NegativeInfinity; } + public float PositiveInfinity { get => Single.PositiveInfinity; } + + #endregion + + #region Methods & Constructors + + private EncFloat_0_8_0(float value) + { + encryptionKey1 = GetEncryptionKey(); + encryptionKey2 = GetEncryptionKey(); + encryptedValue = 0; + Value = value; + } + + private static EncFloat_0_8_0 NewEncFloat(float value) + { + EncFloat_0_8_0 theEncFloat = new EncFloat_0_8_0 + { + encryptionKey1 = GetEncryptionKey(), + encryptionKey2 = GetEncryptionKey(), + Value = value + }; + return theEncFloat; + } + + // encryption key generator + static private Random random = new Random(); + static private double GetEncryptionKey() => random.NextDouble(); + + // Takes a given value and returns it encrypted + private double Encrypt(double value) + { + double valueToReturn = value; + valueToReturn += encryptionKey1; + valueToReturn *= encryptionKey2; + return valueToReturn; + } + + // Takes an encrypted value and returns it decrypted + private double Decrypt(double value) + { + double valueToReturn = value; + valueToReturn /= encryptionKey2; + valueToReturn -= encryptionKey1; + return valueToReturn; + } + + // Single methods + public int CompareTo(Single value) => Value.CompareTo(value); + public int CompareTo(object value) => Value.CompareTo(value); + public override bool Equals(object obj) => Value.Equals(obj); + public bool Equals(Single obj) => Value.Equals(obj); + public override int GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public override string ToString() => Value.ToString(); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public string ToString(string format) => Value.ToString(format); + public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + + #endregion + + #region Operators Overloading + + /// + - * / % + public static EncFloat_0_8_0 operator +(EncFloat_0_8_0 eint1, EncFloat_0_8_0 eint2) => new EncFloat_0_8_0(eint1.Value + eint2.Value); + public static EncFloat_0_8_0 operator -(EncFloat_0_8_0 eint1, EncFloat_0_8_0 eint2) => new EncFloat_0_8_0(eint1.Value - eint2.Value); + public static EncFloat_0_8_0 operator *(EncFloat_0_8_0 eint1, EncFloat_0_8_0 eint2) => new EncFloat_0_8_0(eint1.Value * eint2.Value); + public static EncFloat_0_8_0 operator /(EncFloat_0_8_0 eint1, EncFloat_0_8_0 eint2) => new EncFloat_0_8_0(eint1.Value / eint2.Value); + public static EncFloat_0_8_0 operator %(EncFloat_0_8_0 eint1, EncFloat_0_8_0 eint2) => new EncFloat_0_8_0(eint1.Value % eint2.Value); + + public static float operator +(EncFloat_0_8_0 efloat1, ulong efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_8_0 efloat1, ulong efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_8_0 efloat1, ulong efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_8_0 efloat1, ulong efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_8_0 efloat1, ulong efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_8_0 efloat1, long efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_8_0 efloat1, long efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_8_0 efloat1, long efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_8_0 efloat1, long efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_8_0 efloat1, long efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_8_0 efloat1, uint efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_8_0 efloat1, uint efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_8_0 efloat1, uint efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_8_0 efloat1, uint efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_8_0 efloat1, uint efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_8_0 efloat1, int efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_8_0 efloat1, int efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_8_0 efloat1, int efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_8_0 efloat1, int efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_8_0 efloat1, int efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_8_0 efloat1, ushort efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_8_0 efloat1, ushort efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_8_0 efloat1, ushort efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_8_0 efloat1, ushort efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_8_0 efloat1, ushort efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_8_0 efloat1, short efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_8_0 efloat1, short efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_8_0 efloat1, short efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_8_0 efloat1, short efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_8_0 efloat1, short efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_8_0 efloat1, byte efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_8_0 efloat1, byte efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_8_0 efloat1, byte efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_8_0 efloat1, byte efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_8_0 efloat1, byte efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_8_0 efloat1, sbyte efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_8_0 efloat1, sbyte efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_8_0 efloat1, sbyte efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_8_0 efloat1, sbyte efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_8_0 efloat1, sbyte efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_8_0 efloat1, float efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_8_0 efloat1, float efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_8_0 efloat1, float efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_8_0 efloat1, float efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_8_0 efloat1, float efloat2) => efloat1.Value % efloat2; + + /// == != < > + + public static bool operator ==(EncFloat_0_8_0 eint1, EncFloat_0_8_0 eint2) => eint1.Value == eint2.Value; + public static bool operator !=(EncFloat_0_8_0 eint1, EncFloat_0_8_0 eint2) => eint1.Value != eint2.Value; + public static bool operator <(EncFloat_0_8_0 eint1, EncFloat_0_8_0 eint2) => eint1.Value < eint2.Value; + public static bool operator >(EncFloat_0_8_0 eint1, EncFloat_0_8_0 eint2) => eint1.Value > eint2.Value; + + public static bool operator ==(EncFloat_0_8_0 eint1, ulong eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_8_0 eint1, ulong eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_8_0 eint1, ulong eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_8_0 eint1, ulong eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_8_0 eint1, long eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_8_0 eint1, long eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_8_0 eint1, long eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_8_0 eint1, long eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_8_0 eint1, uint eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_8_0 eint1, uint eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_8_0 eint1, uint eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_8_0 eint1, uint eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_8_0 eint1, int eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_8_0 eint1, int eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_8_0 eint1, int eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_8_0 eint1, int eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_8_0 eint1, ushort eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_8_0 eint1, ushort eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_8_0 eint1, ushort eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_8_0 eint1, ushort eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_8_0 eint1, short eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_8_0 eint1, short eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_8_0 eint1, short eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_8_0 eint1, short eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_8_0 eint1, byte eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_8_0 eint1, byte eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_8_0 eint1, byte eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_8_0 eint1, byte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_8_0 eint1, sbyte eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_8_0 eint1, sbyte eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_8_0 eint1, sbyte eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_8_0 eint1, sbyte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_8_0 eint1, decimal eint2) => (decimal)eint1.Value == eint2; + public static bool operator !=(EncFloat_0_8_0 eint1, decimal eint2) => (decimal)eint1.Value != eint2; + public static bool operator >(EncFloat_0_8_0 eint1, decimal eint2) => (decimal)eint1.Value > eint2; + public static bool operator <(EncFloat_0_8_0 eint1, decimal eint2) => (decimal)eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_8_0 eint1, double eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_8_0 eint1, double eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_8_0 eint1, double eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_8_0 eint1, double eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_8_0 eint1, float eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_8_0 eint1, float eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_8_0 eint1, float eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_8_0 eint1, float eint2) => eint1.Value < eint2; + + /// assign + public static implicit operator EncFloat_0_8_0(float value) => new EncFloat_0_8_0(value); + public static explicit operator decimal(EncFloat_0_8_0 eint1) => (decimal)eint1.Value; + public static implicit operator double(EncFloat_0_8_0 eint1) => eint1.Value; + public static implicit operator float(EncFloat_0_8_0 eint1) => eint1.Value; + public static explicit operator ulong(EncFloat_0_8_0 eint1) => (ulong)eint1.Value; + public static explicit operator long(EncFloat_0_8_0 eint1) => (long)eint1.Value; + public static explicit operator uint(EncFloat_0_8_0 eint1) => (uint)eint1.Value; + public static explicit operator int(EncFloat_0_8_0 eint1) => (int)eint1.Value; + public static explicit operator ushort(EncFloat_0_8_0 eint1) => (ushort)eint1.Value; + public static explicit operator short(EncFloat_0_8_0 eint1) => (short)eint1.Value; + public static explicit operator byte(EncFloat_0_8_0 eint1) => (byte)eint1.Value; + public static explicit operator sbyte(EncFloat_0_8_0 eint1) => (sbyte)eint1.Value; + + #endregion +} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_9_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_9_0.cs new file mode 100644 index 0000000..7d937a7 --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_9_0.cs @@ -0,0 +1,207 @@ +using System; + +public struct EncFloat_0_9_0 +{ + /// A struct for storing a Single while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an flaot. + /// + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + + #region Variables And Properties + + // The encryption values + private readonly double encryptionKey1; + private readonly double encryptionKey2; + + // The encrypted value stored in memory + private readonly double encryptedValue; + + // The decrypted value + private float Value + { + get => (float)Decrypt(); + } + + public float Epsilon { get => Single.Epsilon; } + public float MaxValue { get => Single.MaxValue; } + public float MinValue { get => Single.MinValue; } + public float NaN { get => Single.NaN; } + public float NegativeInfinity { get => Single.NegativeInfinity; } + public float PositiveInfinity { get => Single.PositiveInfinity; } + + #endregion + + #region Methods & Constructors + + private EncFloat_0_9_0(float value) + { + encryptionKey1 = random.NextDouble(); + encryptionKey2 = random.NextDouble(); + encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + } + + // encryption key generator + static private Random random = new Random(); + + // Takes a given value and returns it encrypted + private static double Encrypt(double value, double k1, double k2) => (value + k1) * k2; + + // Takes an encrypted value and returns it decrypted + private double Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + + // Single methods + public int CompareTo(Single value) => Value.CompareTo(value); + public int CompareTo(object value) => Value.CompareTo(value); + public override bool Equals(object obj) => Value.Equals(obj); + public bool Equals(Single obj) => Value.Equals(obj); + public override int GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public override string ToString() => Value.ToString(); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public string ToString(string format) => Value.ToString(format); + public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + + #endregion + + #region Operators Overloading + + /// + - * / % + public static EncFloat_0_9_0 operator +(EncFloat_0_9_0 eint1, EncFloat_0_9_0 eint2) => new EncFloat_0_9_0(eint1.Value + eint2.Value); + public static EncFloat_0_9_0 operator -(EncFloat_0_9_0 eint1, EncFloat_0_9_0 eint2) => new EncFloat_0_9_0(eint1.Value - eint2.Value); + public static EncFloat_0_9_0 operator *(EncFloat_0_9_0 eint1, EncFloat_0_9_0 eint2) => new EncFloat_0_9_0(eint1.Value * eint2.Value); + public static EncFloat_0_9_0 operator /(EncFloat_0_9_0 eint1, EncFloat_0_9_0 eint2) => new EncFloat_0_9_0(eint1.Value / eint2.Value); + public static EncFloat_0_9_0 operator %(EncFloat_0_9_0 eint1, EncFloat_0_9_0 eint2) => new EncFloat_0_9_0(eint1.Value % eint2.Value); + + public static float operator +(EncFloat_0_9_0 efloat1, ulong efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_9_0 efloat1, ulong efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_9_0 efloat1, ulong efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_9_0 efloat1, ulong efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_9_0 efloat1, ulong efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_9_0 efloat1, long efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_9_0 efloat1, long efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_9_0 efloat1, long efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_9_0 efloat1, long efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_9_0 efloat1, long efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_9_0 efloat1, uint efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_9_0 efloat1, uint efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_9_0 efloat1, uint efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_9_0 efloat1, uint efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_9_0 efloat1, uint efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_9_0 efloat1, int efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_9_0 efloat1, int efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_9_0 efloat1, int efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_9_0 efloat1, int efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_9_0 efloat1, int efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_9_0 efloat1, ushort efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_9_0 efloat1, ushort efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_9_0 efloat1, ushort efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_9_0 efloat1, ushort efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_9_0 efloat1, ushort efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_9_0 efloat1, short efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_9_0 efloat1, short efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_9_0 efloat1, short efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_9_0 efloat1, short efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_9_0 efloat1, short efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_9_0 efloat1, byte efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_9_0 efloat1, byte efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_9_0 efloat1, byte efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_9_0 efloat1, byte efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_9_0 efloat1, byte efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_9_0 efloat1, sbyte efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_9_0 efloat1, sbyte efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_9_0 efloat1, sbyte efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_9_0 efloat1, sbyte efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_9_0 efloat1, sbyte efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat_0_9_0 efloat1, float efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat_0_9_0 efloat1, float efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat_0_9_0 efloat1, float efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat_0_9_0 efloat1, float efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat_0_9_0 efloat1, float efloat2) => efloat1.Value % efloat2; + + /// == != < > + + public static bool operator ==(EncFloat_0_9_0 eint1, EncFloat_0_9_0 eint2) => eint1.Value == eint2.Value; + public static bool operator !=(EncFloat_0_9_0 eint1, EncFloat_0_9_0 eint2) => eint1.Value != eint2.Value; + public static bool operator <(EncFloat_0_9_0 eint1, EncFloat_0_9_0 eint2) => eint1.Value < eint2.Value; + public static bool operator >(EncFloat_0_9_0 eint1, EncFloat_0_9_0 eint2) => eint1.Value > eint2.Value; + + public static bool operator ==(EncFloat_0_9_0 eint1, ulong eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_9_0 eint1, ulong eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_9_0 eint1, ulong eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_9_0 eint1, ulong eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_9_0 eint1, long eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_9_0 eint1, long eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_9_0 eint1, long eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_9_0 eint1, long eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_9_0 eint1, uint eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_9_0 eint1, uint eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_9_0 eint1, uint eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_9_0 eint1, uint eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_9_0 eint1, int eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_9_0 eint1, int eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_9_0 eint1, int eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_9_0 eint1, int eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_9_0 eint1, ushort eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_9_0 eint1, ushort eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_9_0 eint1, ushort eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_9_0 eint1, ushort eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_9_0 eint1, short eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_9_0 eint1, short eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_9_0 eint1, short eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_9_0 eint1, short eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_9_0 eint1, byte eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_9_0 eint1, byte eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_9_0 eint1, byte eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_9_0 eint1, byte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_9_0 eint1, sbyte eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_9_0 eint1, sbyte eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_9_0 eint1, sbyte eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_9_0 eint1, sbyte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_9_0 eint1, decimal eint2) => (decimal)eint1.Value == eint2; + public static bool operator !=(EncFloat_0_9_0 eint1, decimal eint2) => (decimal)eint1.Value != eint2; + public static bool operator >(EncFloat_0_9_0 eint1, decimal eint2) => (decimal)eint1.Value > eint2; + public static bool operator <(EncFloat_0_9_0 eint1, decimal eint2) => (decimal)eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_9_0 eint1, double eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_9_0 eint1, double eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_9_0 eint1, double eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_9_0 eint1, double eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat_0_9_0 eint1, float eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat_0_9_0 eint1, float eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat_0_9_0 eint1, float eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat_0_9_0 eint1, float eint2) => eint1.Value < eint2; + + /// assign + public static implicit operator EncFloat_0_9_0(float value) => new EncFloat_0_9_0(value); + public static explicit operator decimal(EncFloat_0_9_0 eint1) => (decimal)eint1.Value; + public static implicit operator double(EncFloat_0_9_0 eint1) => eint1.Value; + public static implicit operator float(EncFloat_0_9_0 eint1) => eint1.Value; + public static explicit operator ulong(EncFloat_0_9_0 eint1) => (ulong)eint1.Value; + public static explicit operator long(EncFloat_0_9_0 eint1) => (long)eint1.Value; + public static explicit operator uint(EncFloat_0_9_0 eint1) => (uint)eint1.Value; + public static explicit operator int(EncFloat_0_9_0 eint1) => (int)eint1.Value; + public static explicit operator ushort(EncFloat_0_9_0 eint1) => (ushort)eint1.Value; + public static explicit operator short(EncFloat_0_9_0 eint1) => (short)eint1.Value; + public static explicit operator byte(EncFloat_0_9_0 eint1) => (byte)eint1.Value; + public static explicit operator sbyte(EncFloat_0_9_0 eint1) => (sbyte)eint1.Value; + + #endregion +} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_6_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_6_0.cs deleted file mode 100644 index 6824640..0000000 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_6_0.cs +++ /dev/null @@ -1,157 +0,0 @@ -using System; - -public class EncString_0_6_0 -{ - /// A class for storing a string while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a wierd string that is affected by random very long an wierd key. { encryptionKey } - /// Every time the value of the string changes, the encryption key changes too. And it works exactly as an string. - /// - /// Wiki page: https://github.com/JosepeDev/VarEnc/wiki - - #region Variables And Properties - - private string _encryptionKey; - private string _encryptedValue; - - private string Value - { - get => EncryptorDecryptor(_encryptedValue, _encryptionKey); - set => _encryptedValue = EncryptorDecryptor(value, _encryptionKey); - } - - public int Length - { - get => Value.Length; - } - - public static string Empty - { - get => string.Empty; - } - - public char this[int index] - { - get - { - return Value[index]; - } - } - - #endregion - - #region Methods - - public static string ReplaceAt(string input, int index, char newChar) - { - if (input != null) - { - char[] chars = input.ToCharArray(); - chars[index] = newChar; - return new string(chars); - } - else return null; - } - - public bool Equal(EncString_0_6_0 encString) => encString.Value == this.Value; - - public bool IsNull() => this.Value == null; - - public char[] ToCharArray() => this.Value.ToCharArray(); - - public object Clone() => Value.Clone(); - - public override string ToString() - { - return Value.ToString(); - } - - #endregion - - #region Constructors - - public static EncString_0_6_0 NewEncString(string value) - { - EncString_0_6_0 encString = new EncString_0_6_0 - { - _encryptionKey = RandomString(), - Value = value - }; - return encString; - } - - public static EncString_0_6_0 NewEncString(char[] characters) => NewEncString(new string(characters)); - - public static EncString_0_6_0 NewEncString(char c, int count) => NewEncString(new string(c, count)); - - public static EncString_0_6_0 NewEncString(char[] value, int startIndex, int length) => NewEncString(new string(value, startIndex, length)); - - #endregion - - #region Encryption Decryption - - static Random random = new Random(); - - public static char RandomChar() => RandomChar(char.MinValue, char.MaxValue - 1); - - public static char RandomChar(int min, int max) - { - return (char)(random.Next(min, max)); - } - - public static char RandomNormalChar() => RandomChar(48, 125); - - public static string RandomString() - { - char[] chars = new char[100]; - for (int i = 0; i < chars.Length; i++) - { - chars[i] = RandomChar(); - } - return new string(chars); - } - - public static string RandomNormalString() - { - char[] chars = new char[25]; - for (int i = 0; i < chars.Length; i++) - { - chars[i] = RandomNormalChar(); - } - return new string(chars); - } - - private static string EncryptorDecryptor(string data, string key) - { - if (data == null || key == null) - { - return null; - } - else - { - int dataLen = data.Length; - int keyLen = key.Length; - char[] output = new char[dataLen]; - - for (int i = 0; i < dataLen; ++i) - { - output[i] = (char)(data[i] ^ key[i % keyLen]); - } - - return new string(output); - } - } - - #endregion - - #region Operators Overloading - - /// == != < > - public static bool operator ==(EncString_0_6_0 es1, string es2) => es1.Value == es2; - public static bool operator !=(EncString_0_6_0 es1, string es2) => es1.Value != es2; - - /// assign - public static implicit operator EncString_0_6_0(string value) => EncString_0_6_0.NewEncString(value); - public static implicit operator string(EncString_0_6_0 encString) => encString.Value; - - #endregion -} \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_7_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_7_0.cs new file mode 100644 index 0000000..c93de44 --- /dev/null +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_7_0.cs @@ -0,0 +1,228 @@ +using System; +using System.Globalization; +using System.Text; + +public class EncString_0_7_0 +{ + /// A class for storing a string while efficiently keeping it encrypted in the memory. + /// In the memory it is saved as a wierd string that is affected by a very long random key. { encryptionKey } + /// Every time the value of the string changes, the encryption key changes too. And it works exactly as an string. + /// + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + + #region Variables And Properties + + private string _encryptionKey; + private string _encryptedValue; + + /// + /// The decrypted value of the stored string. + /// + private string Value + { + get => EncryptorDecryptor(_encryptedValue, _encryptionKey); + set => _encryptedValue = EncryptorDecryptor(value, _encryptionKey); + } + + public int Length + { + get => Value.Length; + } + + public static string Empty + { + get => string.Empty; + } + + public char this[int index] + { + get => Value[index]; + } + + #endregion + + #region Methods + + public bool IsEqual(EncString_0_7_0 encString) => encString.Value == this.Value; + public bool IsNull() => this.Value == null; + public object Clone() => Value.Clone(); + public override bool Equals(object obj) => Value.Equals(obj); + public override int GetHashCode() => Value.GetHashCode(); + public bool Contains(string value) => Value.Contains(value); + public int CompareTo(object value) => Value.CompareTo(value); + public int CompareTo(string strB) => Value.CompareTo(strB); + public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) => Value.CopyTo(sourceIndex, destination, destinationIndex, count); + public bool EndsWith(string value) => Value.EndsWith(value); + public bool EndsWith(string value, StringComparison comparisonType) => Value.EndsWith(value, comparisonType); + public bool EndsWith(string value, bool ignoreCase, CultureInfo culture) => Value.EndsWith(value, ignoreCase, culture); + public CharEnumerator GetEnumerator() => Value.GetEnumerator(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public int IndexOf(string value, int startIndex, StringComparison comparisonType) => Value.IndexOf(value, startIndex, comparisonType); + public int IndexOf(string value, StringComparison comparisonType) => Value.IndexOf(value, comparisonType); + public int IndexOf(string value, int startIndex, int count) => Value.IndexOf(value, startIndex, count); + public int IndexOf(string value) => Value.IndexOf(value); + public int IndexOf(char value, int startIndex, int count) => Value.IndexOf(value, startIndex, count); + public int IndexOf(char value, int startIndex) => Value.IndexOf(value, startIndex); + public int IndexOf(char value) => Value.IndexOf(value); + public int IndexOf(string value, int startIndex, int count, StringComparison comparisonType) => Value.IndexOf(value, startIndex, count, comparisonType); + public int IndexOf(string value, int startIndex) => Value.IndexOf(value, startIndex); + public int IndexOfAny(char[] anyOf) => Value.IndexOfAny(anyOf); + public int IndexOfAny(char[] anyOf, int startIndex, int count) => Value.IndexOfAny(anyOf, startIndex, count); + public int IndexOfAny(char[] anyOf, int startIndex) => Value.IndexOfAny(anyOf, startIndex); + public string Insert(int startIndex, string value) => Value.Insert(startIndex, value); + public bool IsNormalized() => Value.IsNormalized(); + public bool IsNormalized(NormalizationForm normalizationForm) => Value.IsNormalized(normalizationForm); + public int LastIndexOf(string value, int startIndex, StringComparison comparisonType) => Value.LastIndexOf(value, startIndex, comparisonType); + public int LastIndexOf(string value, int startIndex, int count, StringComparison comparisonType) => Value.LastIndexOf(value, startIndex, count, comparisonType); + public int LastIndexOf(string value, int startIndex, int count) => Value.LastIndexOf(value, startIndex, count); + public int LastIndexOf(string value, StringComparison comparisonType) => Value.LastIndexOf(value, comparisonType); + public int LastIndexOf(string value) => Value.LastIndexOf(value); + public int LastIndexOf(char value, int startIndex, int count) => Value.LastIndexOf(value, startIndex, count); + public int LastIndexOf(char value, int startIndex) => Value.LastIndexOf(value, startIndex); + public int LastIndexOf(string value, int startIndex) => Value.LastIndexOf(value, startIndex); + public int LastIndexOf(char value) => Value.LastIndexOf(value); + public int LastIndexOfAny(char[] anyOf) => Value.LastIndexOfAny(anyOf); + public int LastIndexOfAny(char[] anyOf, int startIndex) => Value.LastIndexOfAny(anyOf, startIndex); + public int LastIndexOfAny(char[] anyOf, int startIndex, int count) => Value.LastIndexOfAny(anyOf, startIndex, count); + public string Normalize() => Value.Normalize(); + public string Normalize(NormalizationForm normalizationForm) => Value.Normalize(normalizationForm); + public string PadLeft(int totalWidth) => Value.PadLeft(totalWidth); + public string PadLeft(int totalWidth, char paddingChar) => Value.PadLeft(totalWidth, paddingChar); + public string PadRight(int totalWidth) => Value.PadRight(totalWidth); + public string PadRight(int totalWidth, char paddingChar) => Value.PadRight(totalWidth, paddingChar); + public string Remove(int startIndex) => Value.Remove(startIndex); + public string Remove(int startIndex, int count) => Value.Remove(startIndex, count); + public string Replace(string oldValue, string newValue) => Value.Replace(oldValue, newValue); + public string Replace(char oldChar, char newChar) => Value.Replace(oldChar, newChar); + public string[] Split(string[] separator, int count, StringSplitOptions options) => Value.Split(separator, count, options); + public string[] Split(params char[] separator) => Value.Split(separator); + public string[] Split(char[] separator, int count) => Value.Split(separator, count); + public string[] Split(char[] separator, int count, StringSplitOptions options) => Value.Split(separator, count, options); + public string[] Split(char[] separator, StringSplitOptions options) => Value.Split(separator, options); + public string[] Split(string[] separator, StringSplitOptions options) => Value.Split(separator, options); + public bool StartsWith(string value) => Value.StartsWith(value); + public bool StartsWith(string value, bool ignoreCase, CultureInfo culture) => Value.StartsWith(value, ignoreCase, culture); + public bool StartsWith(string value, StringComparison comparisonType) => Value.StartsWith(value, comparisonType); + public string Substring(int startIndex) => Value.Substring(startIndex); + public string Substring(int startIndex, int length) => Value.Substring(startIndex, length); + public char[] ToCharArray(int startIndex, int length) => Value.ToCharArray(startIndex, length); + public char[] ToCharArray() => Value.ToCharArray(); + public string ToLower() => Value.ToLower(); + public string ToLower(CultureInfo culture) => Value.ToLower(culture); + public string ToLowerInvariant() => Value.ToLowerInvariant(); + public override string ToString() => Value.ToString(); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public string ToUpper() => Value.ToUpper(); + public string ToUpper(CultureInfo culture) => Value.ToUpper(culture); + public string ToUpperInvariant() => Value.ToUpperInvariant(); + public string Trim() => Value.Trim(); + public string Trim(params char[] trimChars) => Value.Trim(trimChars); + public string TrimEnd(params char[] trimChars) => Value.TrimEnd(trimChars); + public string TrimStart(params char[] trimChars) => Value.TrimStart(trimChars); + + #endregion + + #region Constructors + + public EncString_0_7_0(string value) => New(value, this); + + public EncString_0_7_0(char[] value) + : this(new string(value)) { } + + public EncString_0_7_0(char c, int count) + : this(new string(c, count)) { } + + public EncString_0_7_0(char[] value, int startIndex, int length) + : this(new string(value, startIndex, length)) { } + + private static void New(string value, EncString_0_7_0 encString) + { + encString._encryptionKey = RandomString(); + encString.Value = value; + } + + #endregion + + #region Encryption Decryption + + static Random random = new Random(); + + public static char RandomChar() => RandomChar(char.MinValue, char.MaxValue - 1); + + public static char RandomChar(int min, int max) + { + return (char)(random.Next(min, max)); + } + + public static char RandomNormalChar() => RandomChar(48, 125); + + public static string RandomString() + { + char[] chars = new char[100]; + for (int i = 0; i < chars.Length; i++) + { + chars[i] = RandomChar(); + } + return new string(chars); + } + + public static string RandomNormalString() + { + char[] chars = new char[25]; + for (int i = 0; i < chars.Length; i++) + { + chars[i] = RandomNormalChar(); + } + return new string(chars); + } + + private static string EncryptorDecryptor(string data, string key) + { + if (data == null || key == null) + { + return null; + } + else + { + int dataLen = data.Length; + int keyLen = key.Length; + char[] output = new char[dataLen]; + + for (int i = 0; i < dataLen; ++i) + { + output[i] = (char)(data[i] ^ key[i % keyLen]); + } + + return new string(output); + } + } + + public static string ReplaceAt(string input, int index, char newChar) + { + if (input != null) + { + char[] chars = input.ToCharArray(); + chars[index] = newChar; + return new string(chars); + } + else return null; + } + + #endregion + + #region Operators Overloading + + /// + + public static EncString_0_7_0 operator +(EncString_0_7_0 enc, string n) => new EncString_0_7_0(enc.Value + n); + public static string operator +(string n, EncString_0_7_0 enc) => enc.Value + n; + + /// == != < > + public static bool operator ==(EncString_0_7_0 es1, string es2) => es1.Value == es2; + public static bool operator !=(EncString_0_7_0 es1, string es2) => es1.Value != es2; + + /// assign + public static implicit operator EncString_0_7_0(string value) => new EncString_0_7_0(value); + public static implicit operator string(EncString_0_7_0 encString) => encString.Value; + + #endregion +} \ No newline at end of file From 245568048e285cb1b265aa6cf91d36e17d41dabf Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 16:46:49 +0200 Subject: [PATCH 20/53] Update Utilities.cs Removed methods I didn't use --- .../Benchmark/Utilities.cs | 21 +------------------ 1 file changed, 1 insertion(+), 20 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs index 7b24da6..8f90c96 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using System.Reflection.Emit; using System.Text; static public class Utilities @@ -160,19 +161,6 @@ public static string StringReplaceAt(string input, int index, char newChar) public static int GetTheHigherLength(string s1, string s2) => (s1.Length >= s2.Length) ? s1.Length + 1 : s2.Length + 1; - public static int GetTheHighestLength(string[] sr) - { - int highest = 0; - for (int i = 0; i < sr.Length; i++) - { - if (sr[i].Length > highest) - { - highest = sr[i].Length; - } - } - return highest + 1; - } - public static bool IsNumberValid(int num, int max) => (num != 0 && num <= max); public static bool ContainingOnlyDigits(string s) @@ -201,19 +189,12 @@ public static bool ContainingDigits(string s) return false; } - public static int GetSize(Type t) - { - return System.Runtime.InteropServices.Marshal.SizeOf(t); - } - #endregion #region Get Random Stuff static Random random = new Random(); - static public double RandomDouble() => random.NextDouble(); - public static char RandomChar(int min = char.MinValue, int max = (char.MaxValue - 1)) { return (char)(random.Next(min, max)); From c6a39c0b97181abfa48cc63f08c349347c16400c Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 16:47:41 +0200 Subject: [PATCH 21/53] Update TestLibrary.cs - Changed the way to benchmark a floating-point variables - Added tests for EncFloat and its older versions --- .../Benchmark/TestLibrary.cs | 147 ++++++++---------- 1 file changed, 64 insertions(+), 83 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs index e5c6d28..1e5bc9c 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs @@ -130,155 +130,136 @@ public static void WL_EncLong_0_9_0(int amount) public static void WL_Float(int amount) { - float number1 = (float)RandomDouble(); - int timesIncremented = 0; - while (timesIncremented < amount) + float number1 = 0; + while (number1 < amount) { - number1 += 1.77024436f; - timesIncremented++; + number1++; } } public static void WL_EncFloat(int amount) { - EncFloat number1 = (float)RandomDouble(); - int timesIncremented = 0; - while (timesIncremented < amount) + EncFloat number1 = 0; + while (number1 < amount) { - number1 += 1.77024436f; - timesIncremented++; + number1++; } } - public static void WL_Double(int amount) + public static void WL_EncFloat_0_5_0(int amount) { - double number1 = RandomDouble(); - int timesIncremented = 0; - while (timesIncremented < amount) + EncFloat_0_5_0 number1 = 0; + while (number1 < (float)amount) { - number1 += 0.46772781036222716d; - timesIncremented++; + number1++; } } - - public static void WL_EncDouble(int amount) + + public static void WL_EncFloat_0_8_0(int amount) { - EncDouble number1 = RandomDouble(); - int timesIncremented = 0; - while (timesIncremented < amount) + EncFloat_0_8_0 number1 = 0; + while (number1 < amount) { - number1 += 0.46772781036222716d; - timesIncremented++; + number1++; } } - public static void WL_EncDouble_0_5_0(int amount) + public static void WL_EncFloat_0_9_0(int amount) { - EncDouble_0_5_0 number1 = RandomDouble(); - int timesIncremented = 0; - while (timesIncremented < amount) + EncFloat_0_9_0 number1 = 0; + while (number1 < amount) { - number1 += 0.46772781036222716d; - timesIncremented++; + number1++; } } - public static void WL_EncDouble_0_7_0(int amount) + public static void WL_Double(int amount) { - EncDouble_0_7_0 number1 = RandomDouble(); - int timesIncremented = 0; - while (timesIncremented < amount) + double number1 = 0; + while (number1 < amount) { - number1 += 0.46772781036222716d; - timesIncremented++; + number1++; + } + } + + public static void WL_EncDouble(int amount) + { + EncDouble number1 = 0; + while (number1 < amount) + { + number1++; } } - public static void WL_EncDouble_0_8_0(int amount) + public static void WL_EncDouble_0_5_0(int amount) { - EncDouble_0_8_0 number1 = RandomDouble(); - int timesIncremented = 0; - while (timesIncremented < amount) + EncDouble_0_5_0 number1 = 0; + while (number1 < (double)amount) { - number1 += 0.46772781036222716d; - timesIncremented++; + number1++; } } - public static void WL_EncDouble_0_9_0(int amount) + public static void WL_EncDouble_0_8_0(int amount) { - EncDouble_0_9_0 number1 = RandomDouble(); - int timesIncremented = 0; - while (timesIncremented < amount) + EncDouble_0_8_0 number1 = 0; + while (number1 < amount) { - number1 += 0.46772781036222716d; - timesIncremented++; + number1++; } } - public static void WL_Decimal(int amount) + public static void WL_EncDouble_0_9_0(int amount) { - decimal number1 = (decimal)RandomDouble() + 1.467727810362227164677278103622271646772781036222716m; - int timesIncremented = 0; - while (timesIncremented < amount) + EncDouble_0_9_0 number1 = 0; + while (number1 < amount) { - number1 += 1.467727810362227164677278103622271646772781036222716m; - timesIncremented++; + number1++; } } - public static void WL_EncDecimal(int amount) + public static void WL_Decimal(int amount) { - EncDecimal number1 = (decimal)RandomDouble() + 1.467727810362227164677278103622271646772781036222716m; - int timesIncremented = 0; - while (timesIncremented < amount) + decimal number1 = 0; + while (number1 < amount) { - number1 += 1.467727810362227164677278103622271646772781036222716m; - timesIncremented++; + number1++; } } - public static void WL_EncDecimal_0_5_0(int amount) + public static void WL_EncDecimal(int amount) { - EncDecimal_0_5_0 number1 = (decimal)RandomDouble() + 1.467727810362227164677278103622271646772781036222716m; - int timesIncremented = 0; - while (timesIncremented < amount) + EncDecimal number1 = 0; + while (number1 < amount) { - number1 += 1.467727810362227164677278103622271646772781036222716m; - timesIncremented++; + number1++; } } - public static void WL_EncDecimal_0_7_0(int amount) + public static void WL_EncDecimal_0_5_0(int amount) { - EncDecimal_0_7_0 number1 = (decimal)RandomDouble() + 1.467727810362227164677278103622271646772781036222716m; - int timesIncremented = 0; - while (timesIncremented < amount) + EncDecimal_0_5_0 number1 = 0; + while (number1 < (decimal)amount) { - number1 += 1.467727810362227164677278103622271646772781036222716m; - timesIncremented++; + number1++; } } public static void WL_EncDecimal_0_8_0(int amount) { - EncDecimal_0_8_0 number1 = (decimal)RandomDouble() + 1.467727810362227164677278103622271646772781036222716m; - int timesIncremented = 0; - while (timesIncremented < amount) + EncDecimal_0_8_0 number1 = 0; + while (number1 < amount) { - number1 += 1.467727810362227164677278103622271646772781036222716m; - timesIncremented++; + number1++; } } public static void WL_EncDecimal_0_9_0(int amount) { - EncDecimal_0_9_0 number1 = (decimal)RandomDouble() + 1.467727810362227164677278103622271646772781036222716m; - int timesIncremented = 0; - while (timesIncremented < amount) + EncDecimal_0_9_0 number1 = 0; + while (number1 < amount) { - number1 += 1.467727810362227164677278103622271646772781036222716m; - timesIncremented++; + number1++; } } @@ -333,9 +314,9 @@ public static void WL_EncString_0_5_0(int amount) } } - public static void WL_EncString_0_6_0(int amount) + public static void WL_EncString_0_7_0(int amount) { - EncString_0_6_0 stringVar = RandomString(); + EncString_0_7_0 stringVar = RandomString(); int currentPos = 0; int timesIncremented = 0; while (timesIncremented < amount) From d6b8f65e0f51627e56d8e53036df5acc45eb6b07 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 16:47:46 +0200 Subject: [PATCH 22/53] Delete MinAndMax.cs --- .../Benchmark/MinAndMax.cs | 19 ------------------- 1 file changed, 19 deletions(-) delete mode 100644 Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MinAndMax.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MinAndMax.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MinAndMax.cs deleted file mode 100644 index 8d86111..0000000 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MinAndMax.cs +++ /dev/null @@ -1,19 +0,0 @@ -public struct MinAndMax -{ - private int _max; - private int _min; - - public int Min - { - get { return _min; } - set { _min = value; } - } - - public int Max - { - get { return _max; } - set { _max = value; } - } - - public bool IsBetween(int number) => (number >= _min && number <= _max); -} From 8da31c3176abf492b2c6c9f71bcfaf575fce75d6 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 16:49:00 +0200 Subject: [PATCH 23/53] Updates Benchmark Solution - Added EncFloat and its older versions to the benchmark. - Added some more info in the sizes sectionl --- .../Benchmark/BenchmarksManager.cs | 46 ++++++++++--------- .../Benchmark/MenuSystem.cs | 22 +++++---- 2 files changed, 37 insertions(+), 31 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs index bb65650..377a1b4 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs @@ -25,26 +25,26 @@ public static class BenchmarksManager new TypeInBenchmark("EncString", WL_EncString), // 10 new TypeInBenchmark("string", WL_String), new TypeInBenchmark("EncString (0.5.0)", WL_EncString_0_5_0), // 12 - new TypeInBenchmark("EncString (0.6.0)", WL_EncString_0_6_0), + new TypeInBenchmark("EncString (0.7.0)", WL_EncString_0_7_0), new TypeInBenchmark("EncInt (0.3.0)", WL_EncInt_0_3_0), // 14 new TypeInBenchmark("EncInt (0.7.0)", WL_EncInt_0_7_0), new TypeInBenchmark("EncInt (0.8.0)", WL_EncInt_0_8_0), // 16 new TypeInBenchmark("EncDouble (0.5.0)", WL_EncDouble_0_5_0), - new TypeInBenchmark("EncDouble (0.7.0)", WL_EncDouble_0_7_0), // 18 - new TypeInBenchmark("EncDouble (0.8.0)", WL_EncDouble_0_8_0), - new TypeInBenchmark("EncString (0.8.0)", WL_EncString_0_8_0), // 20 - new TypeInBenchmark("EncInt (0.9.0)", WL_EncInt_0_9_0), - new TypeInBenchmark("EncString (0.9.0)", WL_EncString_0_9_0), // 22 - new TypeInBenchmark("EncLong (0.3.0)", WL_EncLong_0_3_0), - new TypeInBenchmark("EncLong (0.7.0)", WL_EncLong_0_7_0), // 24 - new TypeInBenchmark("EncLong (0.8.0)", WL_EncLong_0_8_0), - new TypeInBenchmark("EncLong (0.9.0)", WL_EncLong_0_9_0), // 26 - new TypeInBenchmark("EncDecimal (0.5.0)", WL_EncDecimal_0_5_0), - new TypeInBenchmark("EncDecimal (0.7.0)", WL_EncDecimal_0_7_0), // 28 + new TypeInBenchmark("EncDouble (0.8.0)", WL_EncDouble_0_8_0), // 18 + new TypeInBenchmark("EncString (0.8.0)", WL_EncString_0_8_0), + new TypeInBenchmark("EncInt (0.9.0)", WL_EncInt_0_9_0), // 20 + new TypeInBenchmark("EncString (0.9.0)", WL_EncString_0_9_0), + new TypeInBenchmark("EncLong (0.3.0)", WL_EncLong_0_3_0), // 22 + new TypeInBenchmark("EncLong (0.7.0)", WL_EncLong_0_7_0), + new TypeInBenchmark("EncLong (0.8.0)", WL_EncLong_0_8_0), // 24 + new TypeInBenchmark("EncLong (0.9.0)", WL_EncLong_0_9_0), + new TypeInBenchmark("EncDecimal (0.5.0)", WL_EncDecimal_0_5_0), // 26 new TypeInBenchmark("EncDecimal (0.8.0)", WL_EncDecimal_0_8_0), - new TypeInBenchmark("EncDecimal (0.9.0)", WL_EncDecimal_0_9_0), // 30 + new TypeInBenchmark("EncDecimal (0.9.0)", WL_EncDecimal_0_9_0), // 28 new TypeInBenchmark("EncDouble (0.9.0)", WL_EncDouble_0_9_0), - + new TypeInBenchmark("EncFloat (0.5.0)", WL_EncFloat_0_5_0), // 30 + new TypeInBenchmark("EncFloat (0.8.0)", WL_EncFloat_0_8_0), + new TypeInBenchmark("EncFloat (0.9.0)", WL_EncFloat_0_9_0), // 32 }; static public BenchmarkData[] comparisons = @@ -61,30 +61,34 @@ public static class BenchmarksManager new BenchmarkData(benchmarkTypes[0], benchmarkTypes[14]), new BenchmarkData(benchmarkTypes[0], benchmarkTypes[15]), new BenchmarkData(benchmarkTypes[0], benchmarkTypes[16]), - new BenchmarkData(benchmarkTypes[0], benchmarkTypes[21]), + new BenchmarkData(benchmarkTypes[0], benchmarkTypes[20]), // EncLong + new BenchmarkData(benchmarkTypes[2], benchmarkTypes[22]), new BenchmarkData(benchmarkTypes[2], benchmarkTypes[23]), new BenchmarkData(benchmarkTypes[2], benchmarkTypes[24]), new BenchmarkData(benchmarkTypes[2], benchmarkTypes[25]), - new BenchmarkData(benchmarkTypes[2], benchmarkTypes[26]), + + // EncFloat + new BenchmarkData(benchmarkTypes[4], benchmarkTypes[30]), + new BenchmarkData(benchmarkTypes[4], benchmarkTypes[31]), + new BenchmarkData(benchmarkTypes[4], benchmarkTypes[32]), // EncDecimal + new BenchmarkData(benchmarkTypes[8], benchmarkTypes[26]), new BenchmarkData(benchmarkTypes[8], benchmarkTypes[27]), new BenchmarkData(benchmarkTypes[8], benchmarkTypes[28]), - new BenchmarkData(benchmarkTypes[8], benchmarkTypes[29]), - new BenchmarkData(benchmarkTypes[8], benchmarkTypes[30]), // EncString new BenchmarkData(benchmarkTypes[10], benchmarkTypes[12]), new BenchmarkData(benchmarkTypes[10], benchmarkTypes[13]), - new BenchmarkData(benchmarkTypes[10], benchmarkTypes[20]), - new BenchmarkData(benchmarkTypes[10], benchmarkTypes[22]), + new BenchmarkData(benchmarkTypes[10], benchmarkTypes[19]), + new BenchmarkData(benchmarkTypes[10], benchmarkTypes[21]), }; static public int[] comparisonsChunks = { - 6, 4, 4, 4, 4 + 6, 4, 4, 3, 3, 4 }; diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs index 786660d..67fec5f 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs @@ -330,22 +330,24 @@ public static void PrintSizesOfTypes() SeparationLine(); WriteLine("These are the sizes of each type, in bytes."); + WriteLine("EncInt & EncFloat use a different method for encryption. Large size in memory, but 150% more efficient."); + WriteLine("These are the only types this method can work on."); SeparationLineSmall(); - WriteLine("int size: {0}", GetSize(typeof(int))); - WriteLine("EncInt size: {0}", GetSize(typeof(EncInt))); + WriteLine("int size: {0}", 4); + WriteLine("EncInt size: {0}", 24); WriteLine(); - WriteLine("long size: {0}", GetSize(typeof(long))); - WriteLine("EncLong size: {0}", GetSize(typeof(EncLong))); + WriteLine("long size: {0}", 8); + WriteLine("EncLong size: {0}", 16); WriteLine(); - WriteLine("float size: {0}", GetSize(typeof(float))); - WriteLine("EncFloat size: {0}", GetSize(typeof(EncFloat))); + WriteLine("float size: {0}", 4); + WriteLine("EncFloat size: {0}", 24); WriteLine(); - WriteLine("double size: {0}", GetSize(typeof(double))); - WriteLine("EncDouble size: {0}", GetSize(typeof(EncDouble))); + WriteLine("double size: {0}", 8); + WriteLine("EncDouble size: {0}", 16); WriteLine(); - WriteLine("decimal size: {0}", GetSize(typeof(decimal))); - WriteLine("EncDecimal size: {0}", GetSize(typeof(EncDecimal))); + WriteLine("decimal size: {0}", 16); + WriteLine("EncDecimal size: {0}", 32); SeparationLineSmall(); WriteLine("Press any to return to the menu"); From 5e922e9b0a85eea377990bc5c49051c56f77f3b9 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 21:53:47 +0200 Subject: [PATCH 24/53] Update MenuSystem.cs - Splited long methods to a couple of smaller ones - Fixed some wrong text --- .../Benchmark/MenuSystem.cs | 81 ++++++++++--------- 1 file changed, 44 insertions(+), 37 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs index 67fec5f..6858ce0 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs @@ -4,7 +4,7 @@ static class MenuSystem { - static string currentVersion = "- Current version - 0.9.0"; + static string currentVersion = "- Current version - 1.0.0"; static string titleOfApplication = "VarEnc's Benchmarking Console Application"; static ChoosingState currentState; public static BenchmarkData currentBenchmarkData; @@ -24,7 +24,7 @@ static string[] SectionText(int stepNum) string previousBenchmarkText = (currentBenchmarkData == null || !currentBenchmarkData.IsValid) ? "" - : "\n - Type the letter \"p\" or the word \"prev\" to see the size of each type in bytes."; + : "\n - Type the letter \"p\" or the word \"prev\" to run again the previous benchmark."; switch (stepNum) { @@ -194,12 +194,10 @@ public static int GetTheSpacesLength() return highest + 1; } - public static void GetInputForNextSection(int sectionNum) + public static void GetInput(int sectionNum) { // save input from user - var line = Console.ReadLine(); - - + var line = Console.ReadLine(); if (String.IsNullOrWhiteSpace(line)) { @@ -212,47 +210,56 @@ public static void GetInputForNextSection(int sectionNum) PrintSizesOfTypes(); } - // input for seeing the sizes of the types + // input for running the previous benchmark else if (currentState == ChoosingState.ChoosingComparisons && line.Contains("p") && currentBenchmarkData != null && currentBenchmarkData.IsValid) { BenchmarksManager.RunBenchmark(currentBenchmarkData); } - - // input for benchmark - else + else // normal choosing input { + // if there are spaces, it means the user inputed many choices separated with spaces if (line.Contains(" ") && ContainingDigits(line)) { - string[] entries = line.Split(' '); - List e = new List(); - - for (int i = 0; i < entries.Length; i++) - { - if (ContainingOnlyDigits(entries[i])) - { - e.Add(int.Parse(entries[i])); - } - } - - for (int i = 0; i < e.Count; i++) - { - bool choosing = (i + 1 == e.Count) ? true : false; - AddDataFromInput((int)currentState, e[i], choosing); - } + ApplyMultipleInputs(sectionNum, line); } else { - if (ContainingOnlyDigits(line)) - { - int inputNum = int.Parse(line); - AddDataFromInput(sectionNum, inputNum); - } - else - { - ActiveError("Invalid input"); - } + ApplySingleInput(sectionNum, line); + } + } + } + + public static void ApplyMultipleInputs(int sectionNum, string inputs) + { + string[] entries = inputs.Split(' '); + List e = new List(); + + for (int i = 0; i < entries.Length; i++) + { + if (ContainingOnlyDigits(entries[i])) + { + e.Add(int.Parse(entries[i])); } } + + for (int i = 0; i < e.Count; i++) + { + bool choosing = (i + 1 == e.Count) ? true : false; + AddDataFromInput((int)currentState, e[i], choosing); + } + } + + public static void ApplySingleInput(int sectionNum, string input) + { + if (ContainingOnlyDigits(input)) + { + int inputNum = int.Parse(input); + AddDataFromInput(sectionNum, inputNum); + } + else + { + ActiveError("Invalid input"); + } } public static void StartProgram() @@ -283,7 +290,7 @@ public static void PrintSection(int sectionNum) SeparationLine(); // get input for next section - GetInputForNextSection(sectionNum); + GetInput(sectionNum); } public static void AddDataFromInput(int sectionNum, int input, bool printAfter = true) @@ -355,4 +362,4 @@ public static void PrintSizesOfTypes() Console.ReadKey(); StartProgram(); } -} +} \ No newline at end of file From 886189f6f6e06dc6a7b95295a770cd1d7f13eaa8 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 23:47:18 +0200 Subject: [PATCH 25/53] Update TestLibrary.cs Organized class --- .../Benchmark/TestLibrary.cs | 56 +++++++++++++++---- 1 file changed, 44 insertions(+), 12 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs index 1e5bc9c..fef8d5b 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs @@ -1,24 +1,14 @@ using System; using System.Collections.Generic; using System.Text; -using static Utilities; static public class TestLibrary { - #region Tests - /// A test is a while-loop. - /// A test performs a certain amout of changes on a variable. + /// A test performs a certain amout of changes to a variable. /// There's a while-loop for each variable type you can compare. - public static void WL_Invisible(int amount) - { - int number1 = 0; - while (number1 < amount) - { - number1++; - } - } + #region Int/Long Tests public static void WL_Int(int amount) { @@ -128,6 +118,10 @@ public static void WL_EncLong_0_9_0(int amount) } } + #endregion + + #region Float/Double/Decimal Tests + public static void WL_Float(int amount) { float number1 = 0; @@ -263,6 +257,10 @@ public static void WL_EncDecimal_0_9_0(int amount) } } + #endregion + + #region String Tests + public static void WL_String(int amount) { string stringVar = RandomString(); @@ -366,4 +364,38 @@ public static void WL_EncString_0_9_0(int amount) } #endregion + + #region Utils For Class + + static Random random = new Random(); + + public static char RandomChar(int min = char.MinValue, int max = (char.MaxValue - 1)) + { + return (char)(random.Next(min, max)); + } + + public static char RandomCharNormal() => RandomChar(48, 125); + + public static string RandomString() + { + char[] chars = new char[25]; + for (int i = 0; i < chars.Length; i++) + { + chars[i] = RandomCharNormal(); + } + return new string(chars); + } + + public static string StringReplaceAt(string input, int index, char newChar) + { + if (input != null) + { + char[] chars = input.ToCharArray(); + chars[index] = newChar; + return new string(chars); + } + else return null; + } + + #endregion } \ No newline at end of file From 07097ca10f1370daa3f5205af771e196a809d40b Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 23:47:43 +0200 Subject: [PATCH 26/53] Update MenuSystem.cs Organized class --- .../Benchmark/MenuSystem.cs | 396 ++++++++++-------- 1 file changed, 220 insertions(+), 176 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs index 6858ce0..cd67b53 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs @@ -4,59 +4,95 @@ static class MenuSystem { - static string currentVersion = "- Current version - 1.0.0"; - static string titleOfApplication = "VarEnc's Benchmarking Console Application"; - static ChoosingState currentState; + static ChoosingState currentSection; public static BenchmarkData currentBenchmarkData; static BenchmarkPresetGroup currentBenchmarkPresetGroup; + + public static void StartProgram() + { + // Setup console application + Console.Title = titleOfApplication; + + // Set currunt section + currentSection = ChoosingState.ChoosingComparisons; + + // Print first menu section + PrintSection(); + } + + #region Sections Content + + static string currentVersion = "- Current version - 1.0.0"; + static string titleOfApplication = "VarEnc's Benchmarking Console Application"; static private string choiceText = "Type the number of your choice and press ENTER"; - static private string[] sectionsTitle = + static private string[] sectionTitles = { "Step #1: TYPES TO COMPARE", "Step #2: BENCHMARK DURATION", "Step #3: BENCHMARK PRESET" }; - static string[] SectionText(int stepNum) + static void PrintSectionTitle() + { + switch (currentSection) + { + case ChoosingState.ChoosingComparisons: + WriteLine("Step #1: TYPES TO COMPARE"); + break; + + case ChoosingState.ChoosingDuration: + WriteLine("Step #2: BENCHMARK DURATION"); + break; + + case ChoosingState.ChoosingPreset: + WriteLine("Step #3: BENCHMARK PRESET"); + break; + + default: + break; + } + } + + static void PrintSectionText() { string[] textToReturn; - string previousBenchmarkText = - (currentBenchmarkData == null || !currentBenchmarkData.IsValid) - ? "" + string previousBenchmarkText = + (currentBenchmarkData == null || !currentBenchmarkData.IsValid) + ? "" : "\n - Type the letter \"p\" or the word \"prev\" to run again the previous benchmark."; - switch (stepNum) + switch (currentSection) { - case 0: + case ChoosingState.ChoosingComparisons: string[] text1 = { - currentVersion, - "- Welcome to the console app for speedtesting the VarEnc features.", - "- If you already know the numbers of your choices, you can input them all together. (separated with spaces)", - "- Type the letter \"s\" or the word \"size\" to see the size of each type in bytes." + previousBenchmarkText, - "- These are the types you can compare:" - }; + currentVersion, + "- Welcome to the console app for speedtesting the VarEnc features.", + "- If you already know the numbers of your choices, you can input them all together. (separated with spaces)", + "- Type the letter \"s\" or the word \"size\" to see the size of each type in bytes." + previousBenchmarkText, + "- These are the types you can compare:" + }; textToReturn = text1; break; - case 1: + case ChoosingState.ChoosingDuration: string[] text2 = { - string.Format("You chose to compare the types {0} and {1}", currentBenchmarkData.benchmark1.typeName, currentBenchmarkData.benchmark2.typeName), - "Now choose how long you want the benchmark to be.", - }; + string.Format("You chose to compare the types {0} and {1}", currentBenchmarkData.benchmark1.typeName, currentBenchmarkData.benchmark2.typeName), + "Now choose how long you want the benchmark to be.", + }; textToReturn = text2; break; - case 2: + case ChoosingState.ChoosingPreset: string[] text3 = { - string.Format("You chose to compare the types {0} and {1}", currentBenchmarkData.benchmark1.typeName, currentBenchmarkData.benchmark2.typeName), - string.Format("You chose to perform a benchmark of type {0}", currentBenchmarkPresetGroup.Name), - "When running, the benchmark will perform a certain amount tests for the variable types you chose.", - "and in each test, the application will perform changes to these variables a certain amount of time." - }; + string.Format("You chose to compare the types {0} and {1}", currentBenchmarkData.benchmark1.typeName, currentBenchmarkData.benchmark2.typeName), + string.Format("You chose to perform a benchmark of type {0}", currentBenchmarkPresetGroup.Name), + "When running, the benchmark will perform a certain amount tests for the variable types you chose.", + "and in each test, the application will perform changes to these variables a certain amount of time." + }; textToReturn = text3; break; @@ -64,58 +100,80 @@ static string[] SectionText(int stepNum) textToReturn = null; break; } - return textToReturn; + + if (textToReturn != null) WriteLines(textToReturn); } - public static Action GetSelectionsList(int sectionNum) + static void PrintSectionChoicesList() { - Action returnThis; - switch (sectionNum) + switch (currentSection) { - case 0: - returnThis = DisplayComparisonsList; + case ChoosingState.ChoosingComparisons: + PrintComparisonsList(); break; - case 1: - returnThis = DisplayBenchmarkPresetGroupList; + case ChoosingState.ChoosingDuration: + PrintBenchmarkPresetGroupList(); break; - case 2: - returnThis = DisplayBenchmarkPresetGroup; + case ChoosingState.ChoosingPreset: + PrintBenchmarkPresetGroup(); break; default: - returnThis = null; break; } - return returnThis; } - public static int GetMaxValid(int sectionNum) + // Section #1 + public static void PrintComparisonsList() { - int returnThis; - switch (sectionNum) + // number in list of choices + int number = 0; + + // foreach chunk + for (int i1 = 0; i1 < BenchmarksManager.comparisonsChunks.Length; i1++) { - case 0: - returnThis = BenchmarksManager.comparisons.Length; - break; + // print chunk content + for (int i2 = 0; i2 < BenchmarksManager.comparisonsChunks[i1]; i2++) + { + // measure spacing + int firstTypeLength = BenchmarksManager.comparisons[number].benchmark1.typeName.Length; + string spaces1 = new string(' ', 3 - HowManyDigits(number + 1)); + string spaces2 = new string(' ', GetSpacesLength() - firstTypeLength); - case 1: - returnThis = BenchmarksManager.benchmarkPresetGroups.Length; - break; + // construct line + string line = string.Format( + "{0}." + spaces1 + "{1}" + spaces2 + "vs {2}", + number + 1, BenchmarksManager.comparisons[number].benchmark1.typeName, + BenchmarksManager.comparisons[number].benchmark2.typeName); - case 2: - returnThis = currentBenchmarkPresetGroup.presets.Length; - break; + // print line and increase number + WriteLine(line); + number++; + } - default: - returnThis = 0; - break; + // if it is the last option in the chunk, print an empty line and continue to the next chunk + if (i1 < BenchmarksManager.comparisonsChunks.Length - 1) + { + WriteLine(); + } + } + } + + // Section #2 + public static void PrintBenchmarkPresetGroupList() + { + for (int i = 0; i < BenchmarksManager.benchmarkPresetGroups.Length; i++) + { + int number = i + 1; + string spaces = new string(' ', 5 - HowManyDigits(number)); + WriteLine(string.Format("{0}." + spaces + "{1}", number, BenchmarksManager.benchmarkPresetGroups[i].Name)); } - return returnThis; } - public static void DisplayBenchmarkPresetGroup(BenchmarkPresetGroup _group) + // Section #3 + public static void PrintBenchmarkPresetGroup(BenchmarkPresetGroup _group) { BenchmarkPresetGroup group = _group; WriteLine(string.Format("These are the {0} benchmark presets:", group.Name)); @@ -138,52 +196,67 @@ public static void DisplayBenchmarkPresetGroup(BenchmarkPresetGroup _group) } } - public static void DisplayBenchmarkPresetGroup() - { - DisplayBenchmarkPresetGroup(currentBenchmarkPresetGroup); - } + public static void PrintBenchmarkPresetGroup() => PrintBenchmarkPresetGroup(currentBenchmarkPresetGroup); - public static void DisplayBenchmarkPresetGroup(int groupNum) - { - DisplayBenchmarkPresetGroup(BenchmarksManager.benchmarkPresetGroups[groupNum]); - } - public static void DisplayBenchmarkPresetGroupList() + // Special Section - input "s" in the menu + public static void PrintSizesOfTypes() { - for (int i = 0; i < BenchmarksManager.benchmarkPresetGroups.Length; i++) - { - int number = i + 1; - string spaces = new string(' ', 5 - HowManyDigits(number)); - WriteLine(string.Format("{0}." + spaces + "{1}", number, BenchmarksManager.benchmarkPresetGroups[i].Name)); - } + Console.Clear(); + + SeparationLine(); + WriteLine("These are the sizes of each type, in bytes."); + WriteLine("EncInt & EncFloat use a different method for encryption. Large size in memory, but 150% more efficient."); + WriteLine("These are the only types this method can work on."); + SeparationLineSmall(); + + WriteLine("int size: {0}", 4); + WriteLine("EncInt size: {0}", 24); + WriteLine(); + WriteLine("long size: {0}", 8); + WriteLine("EncLong size: {0}", 16); + WriteLine(); + WriteLine("float size: {0}", 4); + WriteLine("EncFloat size: {0}", 24); + WriteLine(); + WriteLine("double size: {0}", 8); + WriteLine("EncDouble size: {0}", 16); + WriteLine(); + WriteLine("decimal size: {0}", 16); + WriteLine("EncDecimal size: {0}", 32); + + SeparationLineSmall(); + WriteLine("Press any to return to the menu"); + SeparationLine(); + Console.ReadKey(); + StartProgram(); } - public static void DisplayComparisonsList() + public static void PrintSection() { - int number = 0; - for (int i1 = 0; i1 < BenchmarksManager.comparisonsChunks.Length; i1++) - { - for (int i2 = 0; i2 < BenchmarksManager.comparisonsChunks[i1]; i2++) - { - int currentL = BenchmarksManager.comparisons[number].benchmark1.typeName.Length; - string spaces1 = new string(' ', 3 - HowManyDigits(number + 1)); - string spaces2 = new string(' ', GetTheSpacesLength() - currentL); - string line = string.Format( - "{0}." + spaces1 + "{1}" + spaces2 + "vs {2}", - number + 1, BenchmarksManager.comparisons[number].benchmark1.typeName, - BenchmarksManager.comparisons[number].benchmark2.typeName); - WriteLine(line); - number++; - } + // clear previous text + Console.Clear(); - if (i1 < BenchmarksManager.comparisonsChunks.Length - 1) - { - WriteLine(); - } - } + // section's description + SeparationLine(); + PrintSectionText(); + + // section's title + SeparationLineSmall(); + PrintSectionTitle(); + SeparationLineSmall(); + + // section's list of choices + PrintSectionChoicesList(); + SeparationLineSmall(); + WriteLine(choiceText); + SeparationLine(); + + // get input for next section + GetInput(); } - public static int GetTheSpacesLength() + public static int GetSpacesLength() { int highest = 0; for (int i = 0; i < BenchmarksManager.comparisons.Length; i++) @@ -194,10 +267,40 @@ public static int GetTheSpacesLength() return highest + 1; } - public static void GetInput(int sectionNum) + #endregion + + #region Input + + public static bool IsNumberValid(int num) + { + int max; + + switch (currentSection) + { + case ChoosingState.ChoosingComparisons: + max = BenchmarksManager.comparisons.Length; + break; + + case ChoosingState.ChoosingDuration: + max = BenchmarksManager.benchmarkPresetGroups.Length; + break; + + case ChoosingState.ChoosingPreset: + max = currentBenchmarkPresetGroup.presets.Length; + break; + + default: + max = 0; + break; + } + + return (num != 0 && num <= max); + } + + public static void GetInput() { // save input from user - var line = Console.ReadLine(); + var line = Console.ReadLine(); if (String.IsNullOrWhiteSpace(line)) { @@ -205,13 +308,13 @@ public static void GetInput(int sectionNum) } // input for seeing the sizes of the types - else if (currentState == ChoosingState.ChoosingComparisons && line.Contains("s")) + else if (currentSection == ChoosingState.ChoosingComparisons && line.Contains("s")) { PrintSizesOfTypes(); } // input for running the previous benchmark - else if (currentState == ChoosingState.ChoosingComparisons && line.Contains("p") && currentBenchmarkData != null && currentBenchmarkData.IsValid) + else if (currentSection == ChoosingState.ChoosingComparisons && line.Contains("p") && currentBenchmarkData != null && currentBenchmarkData.IsValid) { BenchmarksManager.RunBenchmark(currentBenchmarkData); } @@ -220,16 +323,16 @@ public static void GetInput(int sectionNum) // if there are spaces, it means the user inputed many choices separated with spaces if (line.Contains(" ") && ContainingDigits(line)) { - ApplyMultipleInputs(sectionNum, line); + ApplyMultipleInputs(line); } else { - ApplySingleInput(sectionNum, line); + ApplySingleInput(line); } } } - public static void ApplyMultipleInputs(int sectionNum, string inputs) + public static void ApplyMultipleInputs(string inputs) { string[] entries = inputs.Split(' '); List e = new List(); @@ -245,16 +348,16 @@ public static void ApplyMultipleInputs(int sectionNum, string inputs) for (int i = 0; i < e.Count; i++) { bool choosing = (i + 1 == e.Count) ? true : false; - AddDataFromInput((int)currentState, e[i], choosing); + AddDataFromInput(e[i], choosing); } } - public static void ApplySingleInput(int sectionNum, string input) + public static void ApplySingleInput(string input) { if (ContainingOnlyDigits(input)) { int inputNum = int.Parse(input); - AddDataFromInput(sectionNum, inputNum); + AddDataFromInput(inputNum); } else { @@ -262,61 +365,31 @@ public static void ApplySingleInput(int sectionNum, string input) } } - public static void StartProgram() - { - Console.Title = titleOfApplication; - currentState = ChoosingState.ChoosingComparisons; - PrintSection(0); - } - - public static void PrintSection(int sectionNum) - { - // clear previous text - Console.Clear(); - - // section's description - SeparationLine(); - WriteLines(SectionText(sectionNum)); - - // section's title - SeparationLineSmall(); - WriteLine(sectionsTitle[sectionNum]); - SeparationLineSmall(); - - // section's list of choices - GetSelectionsList(sectionNum)(); - SeparationLineSmall(); - WriteLine(choiceText); - SeparationLine(); - - // get input for next section - GetInput(sectionNum); - } - - public static void AddDataFromInput(int sectionNum, int input, bool printAfter = true) + public static void AddDataFromInput(int input, bool printAfter = true) { // Adds the data by the user's input // Prints the next section // Or starts the benchmark if it is the last section - if (IsNumberValid(input, GetMaxValid(sectionNum))) + + if (IsNumberValid(input)) { int inputForArray = input - 1; - switch (sectionNum) + switch (currentSection) { - case 0: + case ChoosingState.ChoosingComparisons: currentBenchmarkData = new BenchmarkData(BenchmarksManager.comparisons[inputForArray]); - currentState = ChoosingState.ChoosingDuration; - if (printAfter) PrintSection(1); + currentSection = ChoosingState.ChoosingDuration; + if (printAfter) PrintSection(); break; - case 1: + case ChoosingState.ChoosingDuration: currentBenchmarkPresetGroup = BenchmarksManager.benchmarkPresetGroups[inputForArray]; - currentState = ChoosingState.ChoosingPreset; - if (printAfter) PrintSection(2); + currentSection = ChoosingState.ChoosingPreset; + if (printAfter) PrintSection(); break; - case 2: - currentState = ChoosingState.Complete; + case ChoosingState.ChoosingPreset: + currentSection = ChoosingState.Complete; currentBenchmarkData.InputPreset(currentBenchmarkPresetGroup.presets[inputForArray], currentBenchmarkPresetGroup.Name, input); BenchmarksManager.RunBenchmark(currentBenchmarkData); break; @@ -325,41 +398,12 @@ public static void AddDataFromInput(int sectionNum, int input, bool printAfter = break; } } + else { - ActiveError("Number is invalid"); + ActiveError("Number is invalid. Number: <" + input + ">"); } } - public static void PrintSizesOfTypes() - { - Console.Clear(); - - SeparationLine(); - WriteLine("These are the sizes of each type, in bytes."); - WriteLine("EncInt & EncFloat use a different method for encryption. Large size in memory, but 150% more efficient."); - WriteLine("These are the only types this method can work on."); - SeparationLineSmall(); - - WriteLine("int size: {0}", 4); - WriteLine("EncInt size: {0}", 24); - WriteLine(); - WriteLine("long size: {0}", 8); - WriteLine("EncLong size: {0}", 16); - WriteLine(); - WriteLine("float size: {0}", 4); - WriteLine("EncFloat size: {0}", 24); - WriteLine(); - WriteLine("double size: {0}", 8); - WriteLine("EncDouble size: {0}", 16); - WriteLine(); - WriteLine("decimal size: {0}", 16); - WriteLine("EncDecimal size: {0}", 32); - - SeparationLineSmall(); - WriteLine("Press any to return to the menu"); - SeparationLine(); - Console.ReadKey(); - StartProgram(); - } + #endregion } \ No newline at end of file From 07f2ea622e6c2b8da9d9b54c4d94c4242a0d28c1 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 23:49:45 +0200 Subject: [PATCH 27/53] Update BenchmarksManager.cs Organized class --- .../Benchmark/BenchmarksManager.cs | 183 +++++++++++------- 1 file changed, 114 insertions(+), 69 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs index 377a1b4..4ac0e69 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs @@ -8,8 +8,71 @@ public static class BenchmarksManager { static BenchmarkResults currentBenchmarkResults; - private static Stopwatch testsStopWatch; - + static Stopwatch testsStopWatch; + static ConsoleKey key_runSameBenchmarkAgain = ConsoleKey.Spacebar; + + #region ResultsText + + static string[] resultsTitle = + { + " _____ ______ _____ _ _ _ _______ _____", + " | __ \\| ____|/ ____| | | | | |__ __/ ____|", + " | |__) | |__ | (___ | | | | | | | | (___ ", + " | _ /| __| \\___ \\| | | | | | | \\___ \\", + " | | \\ \\| |____ ____) | |__| | |____| | ____) |", + " |_| \\_\\______|_____/ \\____/|______|_| |_____/ ", + "" + }; + + static string[] ResultsDescription + { + get + { + string[] description = + { + string.Format("A comparison between the types {0} and {1}", currentBenchmarkResults.firstTypeName, currentBenchmarkResults.secondTypeName), + string.Format("Benchmark #{0} of type [{1}]", currentBenchmarkResults.presetNumber, currentBenchmarkResults.presetGroupName) + }; + + return description; + } + } + + static string[] ResultsAnalysis + { + get + { + int higherLength = GetTheHigherLength(currentBenchmarkResults.firstTypeName, currentBenchmarkResults.secondTypeName); + string firstTypeSpaces = new string(' ', higherLength - currentBenchmarkResults.firstTypeName.Length); + string secondTypeSpaces = new string(' ', higherLength - currentBenchmarkResults.secondTypeName.Length); + decimal changesPerSec1 = (decimal)ChangesPerSecond(currentBenchmarkResults.changesAmount, currentBenchmarkResults.firstBenchmarkAverage.TotalSeconds); + decimal changesPerSec2 = (decimal)ChangesPerSecond(currentBenchmarkResults.changesAmount, currentBenchmarkResults.secondBenchmarkAverage.TotalSeconds); + + string[] afterBenchmarkLines = + { + string.Format("{0}" + firstTypeSpaces + "average: {1}", currentBenchmarkResults.firstTypeName, currentBenchmarkResults.firstBenchmarkAverage), + string.Format("{0}" + secondTypeSpaces + "average: {1}", currentBenchmarkResults.secondTypeName, currentBenchmarkResults.secondBenchmarkAverage), + " ", + string.Format("{0}" + firstTypeSpaces + "changes per second: {1}", currentBenchmarkResults.firstTypeName, (long)changesPerSec1), + string.Format("{0}" + secondTypeSpaces + "changes per second: {1}", currentBenchmarkResults.secondTypeName, (long)changesPerSec2), + " ", + string.Format("The type {0} performed better by {1}%", currentBenchmarkResults.BetterTypeName, currentBenchmarkResults.GetHowMuchBetterPercentage()) + }; + + return afterBenchmarkLines; + } + } + + static string[] resultsBottomText = + { + "Press Space to run again the same benchmark", + "Press any other key to return to the menu", + }; + + #endregion + + #region Types And Comparisons + static public TypeInBenchmark[] benchmarkTypes = { new TypeInBenchmark("EncInt", WL_EncInt), // 0 @@ -31,13 +94,13 @@ public static class BenchmarksManager new TypeInBenchmark("EncInt (0.8.0)", WL_EncInt_0_8_0), // 16 new TypeInBenchmark("EncDouble (0.5.0)", WL_EncDouble_0_5_0), new TypeInBenchmark("EncDouble (0.8.0)", WL_EncDouble_0_8_0), // 18 - new TypeInBenchmark("EncString (0.8.0)", WL_EncString_0_8_0), + new TypeInBenchmark("EncString (0.8.0)", WL_EncString_0_8_0), new TypeInBenchmark("EncInt (0.9.0)", WL_EncInt_0_9_0), // 20 - new TypeInBenchmark("EncString (0.9.0)", WL_EncString_0_9_0), + new TypeInBenchmark("EncString (0.9.0)", WL_EncString_0_9_0), new TypeInBenchmark("EncLong (0.3.0)", WL_EncLong_0_3_0), // 22 - new TypeInBenchmark("EncLong (0.7.0)", WL_EncLong_0_7_0), + new TypeInBenchmark("EncLong (0.7.0)", WL_EncLong_0_7_0), new TypeInBenchmark("EncLong (0.8.0)", WL_EncLong_0_8_0), // 24 - new TypeInBenchmark("EncLong (0.9.0)", WL_EncLong_0_9_0), + new TypeInBenchmark("EncLong (0.9.0)", WL_EncLong_0_9_0), new TypeInBenchmark("EncDecimal (0.5.0)", WL_EncDecimal_0_5_0), // 26 new TypeInBenchmark("EncDecimal (0.8.0)", WL_EncDecimal_0_8_0), new TypeInBenchmark("EncDecimal (0.9.0)", WL_EncDecimal_0_9_0), // 28 @@ -47,6 +110,11 @@ public static class BenchmarksManager new TypeInBenchmark("EncFloat (0.9.0)", WL_EncFloat_0_9_0), // 32 }; + static public int[] comparisonsChunks = + { + 6, 4, 4, 3, 3, 4 + }; + static public BenchmarkData[] comparisons = { // Enc vs normal @@ -86,12 +154,21 @@ public static class BenchmarksManager new BenchmarkData(benchmarkTypes[10], benchmarkTypes[21]), }; - static public int[] comparisonsChunks = + #endregion + + #region Benchmark Presets + + static public BenchmarkPresetGroup[] benchmarkPresetGroups = { - 6, 4, 4, 3, 3, 4 + new BenchmarkPresetGroup("Fastest", benchmarkPresetsFastest), + new BenchmarkPresetGroup("Very Fast", benchmarkPresetsVeryFast), + new BenchmarkPresetGroup("Fast", benchmarkPresetsFast), + new BenchmarkPresetGroup("Normal", benchmarkPresetsNormal), + new BenchmarkPresetGroup("Medium", benchmarkPresetsMedium), + new BenchmarkPresetGroup("Long", benchmarkPresetsLong), + new BenchmarkPresetGroup("Very Long", benchmarkPresetsVeryLong), }; - static BenchmarkPreset[] benchmarkPresetsFastest = { new BenchmarkPreset(20, 50000), @@ -148,56 +225,57 @@ public static class BenchmarksManager new BenchmarkPreset(10, 50000000), }; + #endregion - static public BenchmarkPresetGroup[] benchmarkPresetGroups = - { - new BenchmarkPresetGroup("Fastest", benchmarkPresetsFastest), - new BenchmarkPresetGroup("Very Fast", benchmarkPresetsVeryFast), - new BenchmarkPresetGroup("Fast", benchmarkPresetsFast), - new BenchmarkPresetGroup("Normal", benchmarkPresetsNormal), - new BenchmarkPresetGroup("Medium", benchmarkPresetsMedium), - new BenchmarkPresetGroup("Long", benchmarkPresetsLong), - new BenchmarkPresetGroup("Very Long", benchmarkPresetsVeryLong), - }; + #region Methods public static void RunBenchmark(BenchmarkData benchmarkData) { + // Prepare benchmark Console.Clear(); - currentBenchmarkResults = new BenchmarkResults(); currentBenchmarkResults.SetData(benchmarkData); + // Run 2 benchmarks. One for each type SeparationLine(); RunTests(benchmarkData.changesAmount, benchmarkData.testsAmount, benchmarkData.benchmark1); SeparationLine(); RunTests(benchmarkData.changesAmount, benchmarkData.testsAmount, benchmarkData.benchmark2); SeparationLine(); - AfterBenchmark(); + // Finish benchmark + DisplayResults(); } public static void RunTests(int changesAmount, int testsAmount, Action whileLoop, string varName) { - WL_Invisible(2000); + // Title of type + WL_Int(2000); WriteLine(varName + ":"); WriteLine(" "); + + // Start measuring time List timeSpans = new List(); testsStopWatch = new Stopwatch(); + // Run tests for (int i = 0; i < testsAmount; i++) { + // Test's title WriteLine("Test {0}/{1}: It will make {2} changes in each test.", i + 1, testsAmount, changesAmount); - // benchmark + // Benchmark testsStopWatch.Restart(); - testsStopWatch.Start(); whileLoop(changesAmount); testsStopWatch.Stop(); - AfterWhileLoop(); + + // After benchmark + CursorUp(); PrintTestResults(i + 1, testsAmount, testsStopWatch.Elapsed); timeSpans.Add(testsStopWatch.Elapsed); } - + + // Display average and add to the results WriteLine(); TimeSpan average = GetAverage(timeSpans); DisplayAverage(average); @@ -209,62 +287,27 @@ public static void RunTests(int howMuchToIncrement, int testsAmount, TypeInBench RunTests(howMuchToIncrement, testsAmount, benchmark.benchmarkWhileLoop, benchmark.typeName); } - static void AfterWhileLoop() + static void CursorUp() { ClearCurrentConsoleLine(); Console.SetCursorPosition(0, Console.CursorTop - 1); ClearCurrentConsoleLine(); } - static void AfterBenchmark() + static void DisplayResults() { - string[] title = - { - " _____ ______ _____ _ _ _ _______ _____", - " | __ \\| ____|/ ____| | | | | |__ __/ ____|", - " | |__) | |__ | (___ | | | | | | | | (___ ", - " | _ /| __| \\___ \\| | | | | | | \\___ \\", - " | | \\ \\| |____ ____) | |__| | |____| | ____) |", - " |_| \\_\\______|_____/ \\____/|______|_| |_____/ ", - "" - }; - - WriteLines(title); - - string[] description = - { - string.Format("A comparison between the types {0} and {1}", currentBenchmarkResults.firstTypeName, currentBenchmarkResults.secondTypeName), - string.Format("Benchmark #{0} of type [{1}]", currentBenchmarkResults.presetNumber, currentBenchmarkResults.presetGroupName) - }; - - int higherLength = GetTheHigherLength(currentBenchmarkResults.firstTypeName, currentBenchmarkResults.secondTypeName); - string firstTypeSpaces = new string(' ', higherLength - currentBenchmarkResults.firstTypeName.Length); - string secondTypeSpaces = new string(' ', higherLength - currentBenchmarkResults.secondTypeName.Length); - decimal changesPerSec1 = (decimal)ChangesPerSecond(currentBenchmarkResults.changesAmount, currentBenchmarkResults.firstBenchmarkAverage.TotalSeconds); - decimal changesPerSec2 = (decimal)ChangesPerSecond(currentBenchmarkResults.changesAmount, currentBenchmarkResults.secondBenchmarkAverage.TotalSeconds); - - string[] afterBenchmarkLines = - { - string.Format("{0}" + firstTypeSpaces + "average: {1}", currentBenchmarkResults.firstTypeName, currentBenchmarkResults.firstBenchmarkAverage), - string.Format("{0}" + secondTypeSpaces + "average: {1}", currentBenchmarkResults.secondTypeName, currentBenchmarkResults.secondBenchmarkAverage), - " ", - string.Format("{0}" + firstTypeSpaces + "changes per second: {1}", currentBenchmarkResults.firstTypeName, (long)changesPerSec1), - string.Format("{0}" + secondTypeSpaces + "changes per second: {1}", currentBenchmarkResults.secondTypeName, (long)changesPerSec2), - " ", - string.Format("The type {0} performed better by {1}%", currentBenchmarkResults.BetterTypeName, currentBenchmarkResults.GetHowMuchBetterPercentage()), - }; - - WriteLines(description); + WriteLines(resultsTitle); + WriteLines(ResultsDescription); SeparationLineSmall(); - WriteLines(afterBenchmarkLines); + WriteLines(ResultsAnalysis); SeparationLineSmall(); - WriteLine("Press Space to run again the same benchmark"); - WriteLine("Press any key to return to the menu"); + WriteLines(resultsBottomText); SeparationLine(); + currentBenchmarkResults = null; var k = Console.ReadKey(); - if (k.Key == ConsoleKey.Spacebar) + if (k.Key == key_runSameBenchmarkAgain) { RunBenchmark(MenuSystem.currentBenchmarkData); } @@ -275,4 +318,6 @@ static void AfterBenchmark() } static double ChangesPerSecond(int changes, double seconds) => (changes / seconds); + + #endregion } \ No newline at end of file From 529c3a5b108ad88519b76e568282d3fe78637344 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 23:50:05 +0200 Subject: [PATCH 28/53] Update Utilities.cs Organized class --- .../Benchmark/Utilities.cs | 38 +------------------ 1 file changed, 1 insertion(+), 37 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs index 8f90c96..36c361c 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs @@ -102,7 +102,7 @@ public static void PrintTestResults(int testNum, int testsAmount, TimeSpan timeS #endregion - #region Special Methods + #region General Methods public static TimeSpan GetAverage(List ts_list) { @@ -148,21 +148,8 @@ public static int HowManyDigits(int n) } } - public static string StringReplaceAt(string input, int index, char newChar) - { - if (input != null) - { - char[] chars = input.ToCharArray(); - chars[index] = newChar; - return new string(chars); - } - else return null; - } - public static int GetTheHigherLength(string s1, string s2) => (s1.Length >= s2.Length) ? s1.Length + 1 : s2.Length + 1; - public static bool IsNumberValid(int num, int max) => (num != 0 && num <= max); - public static bool ContainingOnlyDigits(string s) { if (string.IsNullOrWhiteSpace(s)) return false; @@ -190,27 +177,4 @@ public static bool ContainingDigits(string s) } #endregion - - #region Get Random Stuff - - static Random random = new Random(); - - public static char RandomChar(int min = char.MinValue, int max = (char.MaxValue - 1)) - { - return (char)(random.Next(min, max)); - } - - public static char RandomCharNormal() => RandomChar(48, 125); - - public static string RandomString() - { - char[] chars = new char[25]; - for (int i = 0; i < chars.Length; i++) - { - chars[i] = RandomCharNormal(); - } - return new string(chars); - } - - #endregion } From 177ae1c1ebbeebdee147d44c5adf2aa93f28cc69 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Fri, 18 Dec 2020 23:59:45 +0200 Subject: [PATCH 29/53] Update BenchmarkData.cs Organized class --- .../Benchmark/BenchmarkData.cs | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs index 2f86358..f8e753b 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs @@ -1,5 +1,8 @@ public class BenchmarkData { + // A class for storing the benchmark preferences + // Influenced by the choices of the user in the menu + public int changesAmount; public int testsAmount; @@ -54,6 +57,7 @@ public BenchmarkData(TypeInBenchmark _benchmark1, TypeInBenchmark _benchmark2) public BenchmarkData() : this(null, null, 0, 0) { } + // When the user choose a benchmark preset, it'll copy its values to the benchmark data public void InputPreset(BenchmarkPreset benchmarkPreset, string presetGroupName, int presetNum) { if (ComparingStrings) @@ -68,15 +72,4 @@ public void InputPreset(BenchmarkPreset benchmarkPreset, string presetGroupName, benchmarkPresetGroupName = presetGroupName; benchmarkPresetNumber = presetNum; } - - public string[] DataInText() - { - string[] dataString = - { - "Type #1: " + benchmark1.typeName, - "Type #2: " + benchmark2.typeName, - "Tests amount: " + changesAmount, - }; - return dataString; - } } \ No newline at end of file From 1a9a66355a7a841515e8064aa58d5f7d7d524017 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 00:01:25 +0200 Subject: [PATCH 30/53] Update BenchmarkResults.cs Organized class --- .../Variable-Encryption/Benchmark/BenchmarkResults.cs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkResults.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkResults.cs index 2d73d4a..ac9c57c 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkResults.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkResults.cs @@ -4,6 +4,9 @@ public class BenchmarkResults { + /// A class for containing benchmark result + /// Used in the benchmark manager + public string firstTypeName; public string secondTypeName; From 73f2be01f8edc6613751a1fa7dd48e5eab3d8d90 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 00:04:08 +0200 Subject: [PATCH 31/53] Update BenchmarksManager.cs Organized class --- .../Variable-Encryption/Benchmark/BenchmarksManager.cs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs index 4ac0e69..fa01b4c 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs @@ -7,6 +7,12 @@ public static class BenchmarksManager { + /// Uses of this class: + /// - Runs the benchmark and its tests + /// - Contains the data about the benchmark presets + /// - Contains the list the of types in the benchmark + /// - Displays the benchmark results + static BenchmarkResults currentBenchmarkResults; static Stopwatch testsStopWatch; static ConsoleKey key_runSameBenchmarkAgain = ConsoleKey.Spacebar; From 248c321641254dffa147d00b8c155f7f494010d4 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 00:09:26 +0200 Subject: [PATCH 32/53] Update ChoosingState.cs Added description --- .../Variable-Encryption/Benchmark/ChoosingState.cs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/ChoosingState.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/ChoosingState.cs index 773c0ba..4d1ba36 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/ChoosingState.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/ChoosingState.cs @@ -1,5 +1,10 @@ public enum ChoosingState { + /// Represents a state in the menu. + /// Choosing comparisons means the user is now choosing the types he wants to compare + /// Choosing duration means the user is now choosing a benchmark preset group (Examples: "Fast", "Normal", "Long") + /// Choosing preset is the last section, it means that the player is now a preset from the preset group he chose before. + ChoosingComparisons = 0, ChoosingDuration = 1, ChoosingPreset = 2, From 522fa09e61e2e4e5d1779a5958e91d9d1f2b1fc6 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 00:19:44 +0200 Subject: [PATCH 33/53] Updated description of EncType's older versions Changed the description of each older version of an EncType to "An old structure, just used for comparing the older versions of the EncTypes" --- .../Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncDouble_0_5_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncDouble_0_8_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncDouble_0_9_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncFloat_0_5_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncFloat_0_8_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncFloat_0_9_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncInt_0_3_0.cs | 7 +------ .../Variable-Encryption/OldTypes/EncInt_0_7_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncInt_0_8_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncInt_0_9_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncLong_0_3_0.cs | 7 +------ .../Variable-Encryption/OldTypes/EncLong_0_7_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncLong_0_8_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncLong_0_9_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncString_0_5_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncString_0_7_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncString_0_8_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncString_0_9_0.cs | 6 +----- .../Variable-Encryption/OldTypes/EncryptionTools_0_3_0.cs | 8 +------- 22 files changed, 22 insertions(+), 114 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs index 33f25f9..035e33d 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs @@ -2,11 +2,7 @@ public struct EncDecimal_0_5_0 { - /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an deciaml. - /// - /// Wiki page: https://github.com/JosepeDev/Variable-Encryption/wiki + /// An old structure, just used for comparing the older versions of the EncTypes #region Content diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs index 173c04b..a527963 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs @@ -2,11 +2,7 @@ public struct EncDecimal_0_8_0 { - /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an deciaml. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old structure, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs index 0119a00..7d80c96 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs @@ -2,11 +2,7 @@ public struct EncDecimal_0_9_0 { - /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an deciaml. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old structure, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_5_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_5_0.cs index d2ac0d1..d43fe0a 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_5_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_5_0.cs @@ -2,11 +2,7 @@ public struct EncDouble_0_5_0 { - /// A struct for storing a Double while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an double. - /// - /// Wiki page: https://github.com/JosepeDev/Variable-Encryption/wiki + /// An old structure, just used for comparing the older versions of the EncTypes #region Content diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_8_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_8_0.cs index af5af8a..19c7fdc 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_8_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_8_0.cs @@ -2,11 +2,7 @@ public struct EncDouble_0_8_0 { - /// A struct for storing a Double while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an double. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old structure, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_9_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_9_0.cs index 8ac4394..a61905a 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_9_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_9_0.cs @@ -2,11 +2,7 @@ public struct EncDouble_0_9_0 { - /// A struct for storing a Double while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an double. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old structure, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_5_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_5_0.cs index a3d9f79..806d2a8 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_5_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_5_0.cs @@ -2,11 +2,7 @@ public struct EncFloat_0_5_0 { - /// A struct for storing a Single while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an flaot. - /// - /// Wiki page: https://github.com/JosepeDev/Variable-Encryption/wiki + /// An old structure, just used for comparing the older versions of the EncTypes #region Content diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_8_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_8_0.cs index 55eb9b9..0ff9502 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_8_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_8_0.cs @@ -2,11 +2,7 @@ public struct EncFloat_0_8_0 { - /// A struct for storing a Single while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an flaot. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old structure, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_9_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_9_0.cs index 7d937a7..71d2fe6 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_9_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_9_0.cs @@ -2,11 +2,7 @@ public struct EncFloat_0_9_0 { - /// A struct for storing a Single while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an flaot. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old structure, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_3_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_3_0.cs index a00fdbf..f840dc5 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_3_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_3_0.cs @@ -2,12 +2,7 @@ public struct EncInt_0_3_0 { - /// A struct for storing a 32-bit integer while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an int. - /// - /// Wiki page: https://github.com/JosepeDev/SimpleEncryptionTools/wiki - /// Examples and tutorial: https://github.com/JosepeDev/SimpleEncryptionTools/wiki/Examples-&-Tutorial + /// An old structure, just used for comparing the older versions of the EncTypes #region Content diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_7_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_7_0.cs index 389b5ed..8761db5 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_7_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_7_0.cs @@ -2,11 +2,7 @@ public struct EncInt_0_7_0 { - /// A struct for storing a 32-bit integer while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an int. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old structure, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_8_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_8_0.cs index 0a2e11d..9e25480 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_8_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_8_0.cs @@ -2,11 +2,7 @@ public struct EncInt_0_8_0 { - /// A struct for storing a 32-bit integer while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an int. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old structure, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_9_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_9_0.cs index b5a17d6..c179423 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_9_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_9_0.cs @@ -2,11 +2,7 @@ public struct EncInt_0_9_0 { - /// A struct for storing a 32-bit integer while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an int. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old structure, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_3_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_3_0.cs index e728105..a85d265 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_3_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_3_0.cs @@ -2,12 +2,7 @@ public struct EncLong_0_3_0 { - /// A struct for storing a 64-bit integer while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as a long. - /// - /// Wiki page: https://github.com/JosepeDev/Variable-Encryption/wiki - /// Examples and tutorial: https://github.com/JosepeDev/Variable-Encryption/wiki/Examples-&-Tutorial + /// An old structure, just used for comparing the older versions of the EncTypes #region Content diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_7_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_7_0.cs index d404e5d..a9eca37 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_7_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_7_0.cs @@ -2,11 +2,7 @@ public struct EncLong_0_7_0 { - /// A struct for storing a 64-bit integer while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an long. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old structure, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_8_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_8_0.cs index d1f9d78..ffbd42c 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_8_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_8_0.cs @@ -2,11 +2,7 @@ public struct EncLong_0_8_0 { - /// A struct for storing a 64-bit integer while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an long. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old structure, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_9_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_9_0.cs index 93bb532..ae7aed1 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_9_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_9_0.cs @@ -2,11 +2,7 @@ public struct EncLong_0_9_0 { - /// A struct for storing a 64-bit integer while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an long. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old structure, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_5_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_5_0.cs index 01597c2..e0ceaf8 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_5_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_5_0.cs @@ -2,11 +2,7 @@ public class EncString_0_5_0 { - /// A class for storing a string while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a wierd string that is affected by random very long an wierd key. { encryptionKey } - /// Every time the value of the string changes, the encryption key changes too. And it works exactly as an string. - /// - /// Wiki page: https://github.com/JosepeDev/Variable-Encryption/wiki + /// An old class, just used for comparing the older versions of the EncTypes #region Content diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_7_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_7_0.cs index c93de44..2f4f2fb 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_7_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_7_0.cs @@ -4,11 +4,7 @@ public class EncString_0_7_0 { - /// A class for storing a string while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a wierd string that is affected by a very long random key. { encryptionKey } - /// Every time the value of the string changes, the encryption key changes too. And it works exactly as an string. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old class, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_8_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_8_0.cs index 6a4d8fc..3e801db 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_8_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_8_0.cs @@ -4,11 +4,7 @@ public class EncString_0_8_0 { - /// A class for storing a string while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a wierd string that is affected by a very long random key. { encryptionKey } - /// Every time the value of the string changes, the encryption key changes too. And it works exactly as an string. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old class, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_9_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_9_0.cs index 5683809..ccaf6bf 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_9_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_9_0.cs @@ -4,11 +4,7 @@ public class EncString_0_9_0 { - /// A class for storing a string while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a wierd string that is affected by a very long random key. { encryptionKey } - /// Every time the value of the string changes, the encryption key changes too. And it works exactly as an string. - /// - /// WIKI & INFO: https://github.com/JosepeDev/VarEnc + /// An old class, just used for comparing the older versions of the EncTypes #region Variables And Properties diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncryptionTools_0_3_0.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncryptionTools_0_3_0.cs index 24b10bd..90f35cd 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncryptionTools_0_3_0.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncryptionTools_0_3_0.cs @@ -2,13 +2,7 @@ static class EncryptionTools_0_3_0 { - /// Not a class you should use. - /// But it is a requirement to have it if you want to use most of the classes and structs. - /// Just copy it with all the other files and forget about it. - /// This is just a static class the classes uses to get a random float. - /// - /// Wiki page: https://github.com/JosepeDev/SimpleEncryptionTools/wiki - /// Examples and tutorial: https://github.com/JosepeDev/SimpleEncryptionTools/wiki/Examples-&-Tutorial + /// An old class, just used for comparing the older versions of the EncTypes #region Methods From 9972d875bfbe18aeec3bbd4bee274c62f989c0f3 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 00:22:04 +0200 Subject: [PATCH 34/53] VarEncBenchmark's main class renamed Changed the class's name from "MenuSysterm" to "VarEncBenchmark" --- .../Variable-Encryption/Benchmark/BenchmarksManager.cs | 4 ++-- .../Variable-Encryption/Benchmark/Program.cs | 2 +- .../Variable-Encryption/Benchmark/Utilities.cs | 2 +- .../Benchmark/{MenuSystem.cs => VarEncBenchmark.cs} | 7 ++++++- 4 files changed, 10 insertions(+), 5 deletions(-) rename Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/{MenuSystem.cs => VarEncBenchmark.cs} (98%) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs index fa01b4c..3e2116f 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs @@ -315,11 +315,11 @@ static void DisplayResults() var k = Console.ReadKey(); if (k.Key == key_runSameBenchmarkAgain) { - RunBenchmark(MenuSystem.currentBenchmarkData); + RunBenchmark(VarEncBenchmark.currentBenchmarkData); } else { - MenuSystem.StartProgram(); + VarEncBenchmark.StartProgram(); } } diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Program.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Program.cs index d875b12..059c8d5 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Program.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Program.cs @@ -6,6 +6,6 @@ class Program { static void Main(string[] args) { - MenuSystem.StartProgram(); + VarEncBenchmark.StartProgram(); } } \ No newline at end of file diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs index 36c361c..ff872a2 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs @@ -20,7 +20,7 @@ static public void ActiveError(string _errorMessage = "Invalid input") QuickDrawMenu(errorMessage); Console.ReadKey(); - MenuSystem.StartProgram(); + VarEncBenchmark.StartProgram(); } static public void ActiveError(Exception exception, string msg = "Invalid input") => ActiveError(msg + ". Exeption message: <" + exception.Message + ">"); diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/VarEncBenchmark.cs similarity index 98% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs rename to Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/VarEncBenchmark.cs index cd67b53..8ec7ac8 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/MenuSystem.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/VarEncBenchmark.cs @@ -2,8 +2,13 @@ using System.Collections.Generic; using static Utilities; -static class MenuSystem +static class VarEncBenchmark { + /// The main class of the application + /// - Displays the menu and its sections + /// - Contains the content of each section in the menu + /// - Manage input from the user and use it + static ChoosingState currentSection; public static BenchmarkData currentBenchmarkData; static BenchmarkPresetGroup currentBenchmarkPresetGroup; From bbae5acfae0fe1ae751126900a2f81fc5dcbfe59 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 00:22:25 +0200 Subject: [PATCH 35/53] Update TypeInBenchmark.cs Added description --- .../Variable-Encryption/Benchmark/TypeInBenchmark.cs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TypeInBenchmark.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TypeInBenchmark.cs index b8f0c51..87f63e5 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TypeInBenchmark.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TypeInBenchmark.cs @@ -3,6 +3,10 @@ public class TypeInBenchmark { + /// Represents a type in the benchmark + /// - Contains the type's name + /// - Contains a pointer to its benchmark while loop + public string typeName; public Action benchmarkWhileLoop; From 12ba1bbc2cd1270545b74fd2a5b5543880b137c6 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 01:05:04 +0200 Subject: [PATCH 36/53] Update EncBool.cs --- .../Variable-Encryption/Types/EncBool.cs | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncBool.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncBool.cs index c26b159..f4db616 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncBool.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncBool.cs @@ -8,13 +8,17 @@ public struct EncBool /// You thought you would need an encrypted bool. /// You're a failure as a human being and a waste of life. - #region Variables And Properties + #region Variables readonly bool _value; + #endregion + + #region Properties + public bool Value { - get => Decrypt(_value); + get => Decrypt(); } public static string FalseString { get => Boolean.FalseString; } @@ -34,9 +38,10 @@ static bool Encrypt(bool boolVar) { return !boolVar; } - static bool Decrypt(bool boolVar) + + bool Decrypt() { - return !boolVar; + return !_value; } public int CompareTo(Boolean value) => Value.CompareTo(value); From 47f1c5ca01e37a040d581a957a9f7f491726a6c9 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 01:06:27 +0200 Subject: [PATCH 37/53] Updated EncTypes - Added more overridden operators - Changed description --- .../Variable-Encryption/Types/EncDecimal.cs | 19 ++++++++++--- .../Variable-Encryption/Types/EncDouble.cs | 19 ++++++++++--- .../Variable-Encryption/Types/EncFloat.cs | 20 +++++++++++--- .../Variable-Encryption/Types/EncInt.cs | 27 +++++++++++++++---- .../Variable-Encryption/Types/EncLong.cs | 19 ++++++++++--- .../Variable-Encryption/Types/EncString.cs | 14 ++++++---- 6 files changed, 94 insertions(+), 24 deletions(-) diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs index 84d5a39..0aec94f 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs @@ -3,8 +3,10 @@ public struct EncDecimal { /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an deciaml. + /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted + /// The encryption will happen in the background without you worrying about it + /// In the memory it is saved as a an array of weird bytes that are affected by random values { encryptionKeys array } + /// Every time the value changes, the encryption keys change too. And it works exactly as a deciaml. /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc @@ -29,7 +31,7 @@ private decimal Value #endregion - #region Methods & Constructors + #region Methods And Constructors private EncDecimal(decimal value) { @@ -227,6 +229,17 @@ private decimal Decrypt() /// assign public static implicit operator EncDecimal(decimal value) => new EncDecimal(value); + public static explicit operator EncDecimal(double value) => new EncDecimal((decimal)value); + public static explicit operator EncDecimal(float value) => new EncDecimal((decimal)value); + public static implicit operator EncDecimal(ulong value) => new EncDecimal(value); + public static implicit operator EncDecimal(long value) => new EncDecimal(value); + public static implicit operator EncDecimal(uint value) => new EncDecimal(value); + public static implicit operator EncDecimal(int value) => new EncDecimal(value); + public static implicit operator EncDecimal(ushort value) => new EncDecimal(value); + public static implicit operator EncDecimal(short value) => new EncDecimal(value); + public static implicit operator EncDecimal(byte value) => new EncDecimal(value); + public static implicit operator EncDecimal(sbyte value) => new EncDecimal(value); + public static implicit operator decimal(EncDecimal eint1) => eint1.Value; public static explicit operator double(EncDecimal eint1) => (double)eint1.Value; public static explicit operator float(EncDecimal eint1) => (float)eint1.Value; diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs index ee3102c..0561a02 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs @@ -3,8 +3,10 @@ public struct EncDouble { /// A struct for storing a Double while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an double. + /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted + /// The encryption will happen in the background without you worrying about it + /// In the memory it is saved as a an array of weird bytes that are affected by random values { encryptionKeys array } + /// Every time the value changes, the encryption keys change too. And it works exactly as a double. /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc @@ -31,7 +33,7 @@ public double Value #endregion - #region Methods & Constructors + #region Methods And Constructors private EncDouble(double value) { @@ -211,7 +213,18 @@ private double Decrypt() public static bool operator <(EncDouble eint1, float eint2) => eint1.Value < eint2; /// assign + public static implicit operator EncDouble(ulong value) => new EncDouble(value); + public static implicit operator EncDouble(long value) => new EncDouble(value); + public static implicit operator EncDouble(uint value) => new EncDouble(value); + public static implicit operator EncDouble(int value) => new EncDouble(value); + public static implicit operator EncDouble(ushort value) => new EncDouble(value); + public static implicit operator EncDouble(short value) => new EncDouble(value); + public static implicit operator EncDouble(byte value) => new EncDouble(value); + public static implicit operator EncDouble(sbyte value) => new EncDouble(value); + public static explicit operator EncDouble(decimal value) => new EncDouble((double)value); public static implicit operator EncDouble(double value) => new EncDouble(value); + public static implicit operator EncDouble(float value) => new EncDouble(value); + public static explicit operator decimal(EncDouble eint1) => (decimal)eint1.Value; public static implicit operator double(EncDouble eint1) => eint1.Value; public static explicit operator float(EncDouble eint1) => (float)eint1.Value; diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs index 9bc4854..23778c7 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs @@ -2,9 +2,11 @@ public struct EncFloat { - /// A struct for storing a Single while efficiently keeping it encrypted in the memory. + /// A struct for storing a Single (float) while efficiently keeping it encrypted in the memory. + /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted + /// The encryption will happen in the background without you worrying about it /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an flaot. + /// Every time the value changes, the encryption keys change too. And it works exactly as an float. /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc @@ -32,8 +34,7 @@ private float Value #endregion - #region Methods & Constructors - + #region Methods And Constructors private EncFloat(float value) { encryptionKey1 = random.NextDouble() * 0.001; @@ -190,7 +191,18 @@ private EncFloat(float value) public static bool operator <(EncFloat eint1, float eint2) => eint1.Value < eint2; /// assign + public static implicit operator EncFloat(ulong value) => new EncFloat(value); + public static implicit operator EncFloat(long value) => new EncFloat(value); + public static implicit operator EncFloat(uint value) => new EncFloat(value); + public static implicit operator EncFloat(int value) => new EncFloat(value); + public static implicit operator EncFloat(ushort value) => new EncFloat(value); + public static implicit operator EncFloat(short value) => new EncFloat(value); + public static implicit operator EncFloat(byte value) => new EncFloat(value); + public static implicit operator EncFloat(sbyte value) => new EncFloat(value); + public static explicit operator EncFloat(decimal value) => new EncFloat((float)value); + public static explicit operator EncFloat(double value) => new EncFloat((float)value); public static implicit operator EncFloat(float value) => new EncFloat(value); + public static explicit operator decimal(EncFloat eint1) => (decimal)eint1.Value; public static implicit operator double(EncFloat eint1) => eint1.Value; public static implicit operator float(EncFloat eint1) => eint1.Value; diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs index c52fab9..4aa5dc8 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs @@ -2,13 +2,15 @@ public struct EncInt { - /// A struct for storing a 32-bit integer while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an int. + /// A struct for storing a 32-bit integer while efficiently keeping it encrypted in the memory + /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted + /// The encryption will happen in the background without you worrying about it + /// In the memory it is saved as a weird floating-point number that is affected by random values { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an int (Int32) /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc - #region Variables - Properties - Methods - Constructors + #region Variables And Properties // The encryption values private readonly double encryptionKey1; @@ -26,7 +28,11 @@ private int Value public static int MaxValue { get => Int32.MaxValue; } public static int MinValue { get => Int32.MinValue; } - private EncInt(double value) + #endregion + + #region Methods And Constructors + + private EncInt(int value) { encryptionKey1 = random.NextDouble() * 0.001; encryptionKey2 = random.NextDouble() * 100; @@ -168,7 +174,18 @@ private EncInt(double value) public static bool operator <(EncInt eint1, float eint2) => eint1.Value < eint2; /// assign + public static explicit operator EncInt(ulong value) => new EncInt((int)value); + public static explicit operator EncInt(long value) => new EncInt((int)value); + public static explicit operator EncInt(uint value) => new EncInt((int)value); public static implicit operator EncInt(int value) => new EncInt(value); + public static implicit operator EncInt(ushort value) => new EncInt(value); + public static implicit operator EncInt(short value) => new EncInt(value); + public static implicit operator EncInt(byte value) => new EncInt(value); + public static implicit operator EncInt(sbyte value) => new EncInt(value); + public static explicit operator EncInt(decimal value) => new EncInt((int)value); + public static explicit operator EncInt(double value) => new EncInt((int)value); + public static explicit operator EncInt(float value) => new EncInt((int)value); + public static explicit operator ulong(EncInt eint1) => (ulong)eint1.Value; public static implicit operator long(EncInt eint1) => eint1.Value; public static explicit operator uint(EncInt eint1) => (uint)eint1.Value; diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs index a65b132..352edbd 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs @@ -2,13 +2,15 @@ public struct EncLong { - /// A struct for storing a 64-bit integer while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an long. + /// A struct for storing a 64-bit integer while efficiently keeping it encrypted in the memory + /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted + /// The encryption will happen in the background without you worrying about it + /// In the memory it is saved as a an array of weird bytes that are affected by random values { encryptionKeys array } + /// Every time the value changes, the encryption keys change too. And it works exactly as a long (Int64) /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc - #region Variables - Properties - Methods - Constructors + #region Variables And Properties private readonly byte[] encryptionKeys; @@ -24,6 +26,10 @@ private long Value public static long MaxValue { get => Int64.MaxValue; } public static long MinValue { get => Int64.MinValue; } + #endregion + + #region Methods And Constructors + private EncLong(long value) { encryptionKeys = new byte[8]; @@ -174,6 +180,7 @@ private long Decrypt() public static bool operator >(EncLong elong1, EncLong elong2) => elong1.Value > elong2.Value; /// assign + public static explicit operator EncLong(ulong value) => new EncLong((long)value); public static implicit operator EncLong(long value) => new EncLong(value); public static implicit operator EncLong(int value) => new EncLong(value); public static implicit operator EncLong(uint value) => new EncLong(value); @@ -181,6 +188,10 @@ private long Decrypt() public static implicit operator EncLong(short value) => new EncLong(value); public static implicit operator EncLong(byte value) => new EncLong(value); public static implicit operator EncLong(sbyte value) => new EncLong(value); + public static explicit operator EncLong(decimal value) => new EncLong((long)value); + public static explicit operator EncLong(double value) => new EncLong((long)value); + public static explicit operator EncLong(float value) => new EncLong((long)value); + public static explicit operator ulong(EncLong elong1) => (ulong)elong1.Value; public static implicit operator long(EncLong elong1) => elong1.Value; public static explicit operator uint(EncLong elong1) => (uint)elong1.Value; diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs index f69066c..ca6c0a5 100644 --- a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs +++ b/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs @@ -4,9 +4,11 @@ public class EncString { - /// A class for storing a string while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a wierd string that is affected by a very long random key. { encryptionKey } - /// Every time the value of the string changes, the encryption key changes too. And it works exactly as an string. + /// A class for storing a string while efficiently keeping it encrypted in the memory + /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted + /// The encryption will happen in the background without you worrying about it + /// In the memory it is saved as a wierd char array that is affected by random keys { encryptionKeys } + /// Every time the value of the string changes, the encryption keys change too. And it works exactly as a string /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc @@ -41,8 +43,7 @@ public char this[int index] #endregion #region Methods - - public bool IsEqual(EncString encString) => encString.Value == this.Value; + public bool IsObjectEqual(EncString encString) => encString == this; public bool IsNull() => this.Value == null; public object Clone() => Value.Clone(); public override bool Equals(object obj) => Value.Equals(obj); @@ -208,9 +209,12 @@ private string Decrypt() /// == != < > public static bool operator ==(EncString es1, string es2) => es1.Value == es2; public static bool operator !=(EncString es1, string es2) => es1.Value != es2; + public static bool operator ==(EncString es1, EncString es2) => es1.Value == es2.Value; + public static bool operator !=(EncString es1, EncString es2) => es1.Value != es2.Value; /// assign public static implicit operator EncString(string value) => new EncString(value); + public static explicit operator EncString(char[] value) => new EncString(value); public static implicit operator string(EncString encString) => encString.Value; #endregion From 3625d65c57b45061da6f53936eb3e253cab41cfc Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 01:07:28 +0200 Subject: [PATCH 38/53] Update VariableEncryption.dll --- Benchmark/VariableEncryption.dll | Bin 96256 -> 151552 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/Benchmark/VariableEncryption.dll b/Benchmark/VariableEncryption.dll index 9d171ea7ffebc2cbb5d5da8b67585f1197056fe7..0f3652d94f29821759f9edd236d671fe4c279287 100644 GIT binary patch literal 151552 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®WIqUs)UEeb~mf#T(?aq};TPa>Yme=VSZUUX`19V(*E$)+RX*l~U(g zTjX)5h%?vPDnEisLfaei%P7~LYweH^p%U6c>n-_9R7zcFy(9mGiZ~0ccV+!C_Uvqn zzR=nwS3tS;LTis)6P3`GTKnWHQ7Lt)bwIur6>*kY2j$+VB(!}X4@J55QtKmm0xF?B zZG9pqQ7QFl>#)2C6>*-nj>>CLNoYGJZ$Y{C)7BUAUQ|MR&N?n1L#5Q`tP}DXRK$7C z`dU^Nom->ltZ(IVDA#_@Iw{vcCA9U{X}Jk1rLMQWm)oNv&U)(yITw|LwzKjOlxwfI zewN3h5*l3pG&Bp9Qa4$_&||2Gv&rH^t5Hd46GNL(uD!{ULwitgH5f|?eTIUo!B|@8 zdlXy^#xg>o#pl*&yJdwkP;fOED;&BEmF2u^MMF(c*`V}LCsd~Tt`!gULFIrlLL(?| zzg0domGbsm7lh_h-hQiM=xNH^Z(S7HNO>Pwl|%1Q-bdCYp<|TykySPH1Lb{WRS#*8 z`|FV9d}h@MU4Y64T^_27%2YqI5}}r;98jH5H_AIyW9QwQ@oi zqjEskgswnkIcav=PzO{tsC{TKO_^qQ2u(+2s%dto&=M5hj+E1!rUmyC6bg|t%bc$5Xz9E#h)L-f<;aYZ&kWH#*_Y7S~YGn5cRV6jE zZwxgc<=DBQY)}4nvv;VIC%;1X4)sBK*A)v*@#I(NywEHZtI&C&`TmsNHZ?EwwkQ9( zR5yi=`)yu@zA04x3AWViOc1yNS*Wcize4v34IyRo1)=*;tU})$dcl)lq5FmoqF9CQ z7dnemvI^ZVRQ^f!4E}byU#PLC$=;cl{X)G-xoL%=Nu;8*qR``>ScPtH4+w2WrPTKJ zpwMAd#A$C238g*7o`KcY_I7dTB9v>lw}*wAq7qs+dqk)sDy4R_M}_iG5vQAdOK2!6 z32kFS<58~N%^n+?iArcU+T%ixqEhOO_Jq(XRK&T_o)p@INt4~OEYY|znAO;o1(lzl986)FexMW`d?t+bDaZlb)E_KDC4 z%3EoF9hyRUEA4MXb1Cmd`($V}<-KU14!uWHzG#0R`U;h)z6fVYtIzn$>4rDjXG0NG zmGJBKPoYZG_NM)Fs1~)oXa5pvLfUV0N*mILc0lP)I${TvzNEjv`P9Qn-`Kn|k@TG{ zD0h*5wnb$gi4RN4lb-wvEi2D?@~=-ME3bL-YqG4og<>^XRu1}8LQNhb$x4l9+1mP7 z9SSLpJh3V~Lei9;p8P7TDdR}lysj)lu_|mRTRr(z*i??ASQWMuZ6$jKf1j15)bQk2 zVM}R?ZR~rpr3@kErrFAUq@uL2@|-7Dg_Uqr*^Pp8&co@-NfexO9*!%KRqXj#6;{F- zN*xrOa~>|QbVR{%>ER2MJQN(49_R1>?Q-P^%C$4X3FR~@p;ZdkQKZ%WQm52P;VYClD&kZM z*H@~clF-&r$wIkyrEr$g29?mNh8rtAQ7N@*_)29UD&kZPU#*NqC84dEaxcoYtA<-B z3s4EIRybRE7L`(Kg>#fwQ4yzB_!{LsR1(_SDu+?7T`SyPIfY7S^}`($am~3ksvqv8 z#845Zez=QL6_r%$hp$sIQLbG-e7$lFDxozA-=OqBrPL&M&*Etm3pWwr&D;C(h8Lg8lm*0yiVa!${@><@F9vRru%qrOr`%hwoImV}>D?j$XTbF}A@R)v=<3rR19S18YrHiVy6Uh(8t z;b)W`ejE3Iy(RpNauW3{zcKWTQvOA6jkt@I{?ao_D^KV0I(uT(n+rap+>F{KS==+q zEuJRJ{X_k@XO*d*=5WL1H^R>`KyW zl%A-kJk3STHXh{GC|{$x!&RoAS1PV$bD7L-jh+s?q$E7~RsSWWEs9nBwMrip+aI!4 z8SjbhZQ2`NtK5sq2CY}-Q`-mOSCnU{?St?}X0|H}NF(?i z%8GMSYPa%lDjQMDLl<&8mA6Tg_;-~LNYnXU$_dmhMv~vF{D@+I1MOAh_5SNuU!DtX zanb_*fO08m34c&&KpMe+sI(-l;6GBjlGgB_Dt$<6`6Eg(X#;;$nMB&gf1xB%7dvnB z$CZVo-Tarzv!p}(*UAP|`^aJbTjgz3E4Z`4N#!8v1n3J?9ay7N$`7Os{P&9XvcI-< zpxTI50?5g=_GHd>rr3YKk&A?o%9PIRu7=8@DF@cJx2P4chv7tmE<4zm@2&D zuWcn+5aMbSH7`vSGSrJnwoqQJgUSrYgbUPWq>F?~Y6ns^;UYDcR9mR54kk4gE>*{p zvW05u-Kgi_{dt)>k2IaHp*}^L#Me?^LhXX3uB~n*2|^upFKTPFgK&jrK)J)sMvHCda^FR~zInn^`O7(S8 zzHqg=-_uNPLiC4lbM-4vb2wJZTdHSCI;h-64*t#ISS@d*Rz&+ zj@9y3YV=h>7bUN;2Oe_PU?7+8!jK|qD~`S z9O(u$4{JMLc`V5NI-Rsm%p8UGoP2K6que;sUeb~n8Za4L)FQ~iKBiE~E zP^|8DSNYf28cpU{-R-X0p8UGoUA+*+>h29{4V;qI-5b;_6sx;E)Ev?XzNdQKxhbLU z_EHN`tnTKiBT19^o7Bmq>3kn`4vN*?zUpHrR(JcV&!AY{?W=AeE#QmPw@FL*0qTdO z5&U5FOVSE{i24(04PT;aoBVaJFR$f?s~MyX{0OxMX&Zlw+6cw!?ijT-X*YkH+MRTW zAE)+1vAR1!9f@Lfcal1ZbOJOB#p>=I>Z7C${8V){X$gOqx{0)azgK;aG=iV0eoR`y z&r-i3t>I^@+-86M>d4#p`&E;)mVZF4fMRv`LG?1yA%32kMcU2JSFb^_y1PK_Mmota zPzzA3?k-eINWbupsuNJG?k-YikbdD8tB;^q-Cd$CCket*bsdV;-6z%UBwJXf9ze0W zyF&efbdm6^`aP+duu_$_`0Jh-t}U!qW2DBy^Xes}Y~e+<9*Wi7wQ6(Hbbg)MnKX%i zMZF2d>h4B$2uToLRc}YJy1PlehjcoyMV*IYb$5%pl+;bwqCSUWb@z4kHBWxseO-MA z+gROwUHt&X>h4zcFQjh5R`m>u)!l8X_`1LDtnO}8Bcxu!HnkFp)!jGLS}0a`x2sKj zd3AS(+Me`z;7#>L(g5x)bucMkct;)YiPhcOk@wX5Q6u1v9lO{+tMf?BBk!wEpt77ckwfb9sBF-O>Sh!iAr<*peUo%UA0s($Rrucn`>Cq4P~^HVjjjV+5`KR;DvPm^Up6pPLfu=jZAJC{{neRF{w@ z@h8;hNYnYR)h#GiKjH2MC{{mH>PIM6KjA9Iqy_wG^%v3-{(IGYgZ0E@uD(2i|52?# zTEU-HYm(ORzo?B#Yx#h74QT@()OwP(@uJor#p+Ii6sw=M_AY4yAJq<%mhf@yBxwO(PD|VFuU{QlzY3a7TESnSRU)n7D`^SR zHvVGmD$-iMiq;Or>gOd|57Ht2Qmu%zo3Ezbf@1ZvhBk$ClCPo7MzQ)?Q+tf`3xBz` z62jbin)u6Bqd2v=ywQLKK}*M20~LPJg2;jcTZpIKT4=^~+tR+Usu zxKe9Csx4ftwIVeZnrqjQvW1pf0gBbnR$2*ZI-jFWBu(PmXtPkPezwyVkOZN<_B4vs z&kowlq|<>;+IAGHpPjUQq;5hd?I?=X&(2!PlV3kOYuuau+OqoDSu;?qesNj$Uoi)2>f2rq!d{gx_<>r)(;WFOSeAiW2I?VC zl{~R?$7e(aY6(wlpZM&^AT7slgMH#(@PoBJp4dKdxC5j%j&x1h5bYtcV?C^BDr1(i|{MIO=KLq(iJ zk%ii4s3f#Kru~R=?L(2pnz_qg&V+U}vP8QWl~RvJp3oYgBF@psQ(7BT655t)xhU5@ z8hKhPLBSahk!Q6jC^+LGvPzqWf-@c>YqY0PaK=OAdF?e6obeEOQQM1xYavF~YJWk& zwGbogwO>$hEyTzxT4eXR-u*tZQM(ic*FucErZqw(v_N#Tb}cHU2BNQP`KX8!h;GwH zqLR?IU7L<_?LhQR?GY6GniPFoTZMvOlcGDd*HQ3mQuICTeH8qf6y2?Tg@Rv`qI9Q{T+fr4uf zM^jpGufGm(?cwMtEgc2F14X~ns-xg{py(OxN)-GK6#Y@_go59JqCaUjqu_U-=r7tW zC^#1}8qn`W!MTXhG<^{Y&P9w0`im$y7cna7Z&6;eXh{Er@|s0e{WMM4EUN3uK7Xlm z)MimrzW|lxTobkRI;d<=M9)TLs@Fsv{RYarCK}TRQC_F0t52Z3PSJAu9Lnnyt)M?i zd7Yvc>Mv8?4be*ayOeiB^kV%e<=qgiqW?g7H$*Shjs5;o!<7T0)%1%{*`Ukx`lw9x zrf5z58dMIbmVP7U6-8_7#gtbRt*cL_yrO75{XxnriZ;+!P+oB~Q-786ildG6J(O1* zZK8icdBxGI^q(p3mS|Hwe8697*!o7B>zAN1)mx%1^(<5lsFmIx1y}fuw$^)5-h^ly zeE{W6h_=&jrMwBzYxO%RZ+f(&{xIcDk9O8qQr`4vSA7fRO^L@onFPf*rqw0-$V!MJ4oM0 z2kGyVeu)m&KPQRK5dAxn?hMt1gMLp`2}hk`Jwhtyl<1X67dgZ9TBK@l4TvVBgfl{K zN|;P9BN;XX*#Nl!!!p~=xL!R_I+YA zv~BXlzCko_M(NriwnqL{gKyEV_v9a?aEm^SbS&*weFlnMHF%7^%#;6(>^6NXihY9^ zs~^TG**CJWI`;v42LBt`SiQU_{~Os@y&)+#?RLEjsVHrnKGYNY262@$L7#$xYpOYu z^!X^brkXQZUxk8esyS2jZ78^=nscZAAu6G@aqiNOqf%-c=N|nGD&n+pX6WLFY&qHY zkT%XNJ%V!WHqL!|MN~rT?99&N{59%#YNoadW?|^dc&d$SnPgFwd z;VjS#Q7N^D^Qb-o6>)kvi}Z=8B(y!Q&p^3$4`-=9AC=JZohS7tP$@OvS*EW+MVx$R zg}xD$gtlk&H&L#g@2u4KqY_$wXSIF=l~VgV&*|TwB2Itj1^p*f653wULm&CQ;>_8g*F?b)XU?m7CJK%?b2jNMQE!^w7sQ|N4fT`&O7?usDw7rc~^e`l~N}!NdE$rgtkxgQz+M-4%gz~KIY&bd+#Ql zqq>GlsY&OU9!Eu-r1OPd8I^>#<9Y(++DYex-WUaUVRgRN+oRwvtj@Q3J__!;>YUVv zqu`#b&S`xLuC%25|PKkKhj-g1XC-ln|ePSE&}@|HWi zah&p&JEC!h^42)AA${Vnd$zO2QH(e$Q(XgBwYUV812T*&P+87;$1<8y-g+l&bfmoX zPSm)O^42@)Mt{oN?8J>xl(*T*Fs4%8W_INY%G>N*U_45BZ#or?rz!7E=OW`3%6rqP zZ0w-CH=Rq2{gk)cscIahyxnj;iqn+0+o@rsed@1!j=I~q+^|qt&LJmZR6u2e>KHXq znd%|u3L}g14mtIWR+M)Ht~t?z@{TxJ#$d`j;xslUQr;2gO5=XYI|0|6c#QH+IL(Ze zly|~uVZ2OvC!B2K4az(1~t_xl91lf zh?2DQPR0eKNP1`EQc^~G7b8Kcl-||IBvnnn&S*xemEO&0gQ^m)pMJg3o!YKU?{4Ig zTBhG%6w#Dz(|Z`BsI5zSPh&i_^+@k!Oefuxexos)RG6M?JVF|h-rIPBG%`KUSVbC} zev`4DbVqu=@jB_Q^ghN;QZl{3c;A!1?Z4Uh%oE#tuwT5{_!_6YOWP8@+4v5n%S=C` zzLS`QBYw~C3o>b_E)G)!Rp_a_C;v)*Hya~8v2Fh`rLQs8Z}ZNoEi&%&#J2r9Ut~N( zx+bl^vBQ(UwI5&{!!~v$zkvpSlr4*YUe+L^q9=dv!62hCwy`|~gN*C3jqQaSWDFza zrVTb`kc!fV7|T7e`uSjbvGE!zr9PNG%-D~LI1i?eFup=1p$)Fg@fp4&?FZ9uG0LG5 z+T-bCjH;-V`gr|DRRoc^fcpc2}a^hHJ` zR7%~F{+wtFEuhzNoaf0Xo+&|E$PdQj;Mt8R{9E~7b>N`mHv!Th>AFGrLQ!G zqmt0J+8B>=?YGjOGwwzuv_0uB7!ROQ>YntMjK!#kvnPF>@hmC{Z7&<^QLeoweS@(L z1$X&Mf7RHHg1daBZ!$hc!Ck)6w-{fd;4WY3Ta7a)xXV}i8;09EUmI~$rYgt2H7-HrfKD1$pt2k*cG_r4c~6u^)^Z zDbI?XHTqLtJod9Oit^$y&YVhl@mSEDO?mMcZ$3(S6=S0LH04!{$>uARS23oTJ1DPW zOf&aWUe%ak9;LjhG0Qwnc~xU!Gwm<_y631>V^PyW!Mz=0>1G8K+}kl0H*2Ec-j1;h zGmG*PvGQgs%4-7m%v+9nEzpc1?>;<~~pUwz#u-62<=V?qXUe*z@^Y z-!5hiPyS!tUCbP8V_V-YW*<^+T32%%sVMC_bH1lJ@}RUYW7nIjP`Bw{#%?gTq3#6r zG(V&%&%|ytzo044#Cn^jXv#COn@sL2wq$eUVE9a|k7=Mz*=J%mo8?gn?aNp{vkoey zeiv=kU0hg*X@lzY)(PJb$jCr%vmV7 zZg2cib3O|0up3`wK8=Dq?8YBAH=*FVKk=pJ9u!;?DE_2*jPfpvFEdY3-evI>rtpp5 zFPZ9P@n_61DhIUEybzV;)Qzt;YoM}0&zX%WuWtMWvo+<_jlX1GM|q9n>&%-duTlJE zb13CCif=G)qr67(SIudZ*F3(-oK1Pn<6F!{l-E4I)qIBXn#bQT*HK=Z_zrU$<+X{w zW$vfEHt~1Nqm6?RHRX+o2d(Q+Rl<|vyp>Cu9v7^Bq*-y%8iI1e55y&F6lp(4v+mpXlt7wfuv8`GqYc5X7_9s`eR%09co3fJi z4z{taS|#f^DL3sROFr#CJG(l>#a0zhY^zqotztDo-KN)YFSRVj5O=)w zC@LE?(OQYhREM~CSg)Yq{^9NvYX{|xa;I7QDQ}cJ-TIvJM!9!erzvlgd#{yt#_yLb zXPi6JvQThkQa5Q;L}jYu+}T!5R1WBVD~s}`x(`^bC~vAe&+0~bQ{DMiAIh8RK4J}} zyczC7Yb@o>a38bop}ZOHVrw4d&2X1kODS)z`-HWI^5(ivS(_o1hIz+GkiKzR$?HJ12;-xE3N0{3}1knUW+EOlSBDx2-ILbvx-Tce6E>wARwsnkD zKI0whThhfDJFT;%>KX4^;*WlxRSDP5c+av>Zn$B_F6#o))fv03s-#vKd#pO1{H@Gh z>q<{-E5il%TG^ibBX9RwoiUG{F}Byb0o&M-w|lLAzPP?h`;2|oP!v1zcE2?S#g4q) zZ%y;$Z%OuB_oLXB!ryYJM#83s~n1LxjwV1qS%qQpIHq_3-~XrR-`5TajP3?1pk#) zKw80nZ4D=_;ZxQm(pvtMHH)-?KW!}{ZR3BiR-xFDw`Z-5q}}{a)=ttPp0htfu_JGT z_E#u&1fxQ0&Ot%C`KozqVHR7ru%eL$M=oFSVvV|IUClovK_Hz3s z(nUgTdkCqTP{+QVR9m>hzL(TkXkb4~$`&&1u_JF=*^NB;dmUQYIoQU& zpS7~DL$M=obL@OlHzCI!ieg9JwzkKj*paub?dhamLTmd06g%?v8hZ(f9eLZvUgHbC zn_663`ylD_Ks)<5X#m&W{)v>E&7&ajN`c0W`$sE0j*+Qww`vZqnon2cQeArxHEEhEofgsKw0 zJL4vM8MV#M$hTK}@~dedn}a3W2#XWsj3CFQanr&a$8&OojsFS8lx_`hJ7M}DH&Zu`7fzl!%- z`}6VR2=CczdaqR2n?GANwuJ22>v^w2=~ut>@J4SLKK16D@aFt`hu`#aGrZj2JN$c} z>-SFYuPMtq_dYMZ?*H>JdyN8I*y}z2_40>*?=qC0{`dAz+4TR|`>L$petW-_et(t? z|6?`qzq#K^*I3pM0q!4*=c{p$djsZ^#>KpC%K7oXuHj|%`L}<@%j)63Z(sd4*Osz% z|Kr=EKfgZzx(@&GzaXCV{(|_~+jjik;eYl!q;&87y)9Ac@qTak@%-No0q)QG3*z_o zPucYU*!$|gt>6CHpQEz*|M5!xuiS^F>m*ywf978SWi_^}ru{qC=YQqTZ`rc_>(}Q$ zzsCOA-{jx-zR6eh_S^j4;eYl!uypU0{>J`45C5~bHNUr)%BKIv-d+EW{r1oPM3l|{ zU%%%6k=Lkn#bfjNcm7WP@A&yGTju|rTKz{pBW1b&*){ODyuN>ao&2-ESO1o^_`jN_ zbnpGo-=+Q5fA%-(|Eqo|d)~52^56CzDE--I>;A{TVg9;umaZpdb))R__22gS`cGZo zKfiAL{bR<;>PA`J_)q;D{kN^xpIT0@`n}6v zHhtN9zU)2l+us9!{^vcw_43Z*zt=mX+&@=6lE%(1Hy!pZ;&0De_qY3dy>IfBy>Ifr zW!PWx3Eou&{OFHiXT%3Me~dq8f4m>x^X7l2ckcW~Si&@J4h-|$)1|IOz@`jxl|?om zf4C70r*U;ljadR&X}_AL^z?q~-_G-|#|Jq!ru5%{{+KjxdH7$=-=FeIZ+%%TJ!OD9 zKPKSKGl)e?CXmlU9x%2)sY1~=wDiCZ8Twj95mmV%X zO|aDT=Z4R}i-O$Wz90PlDZOlud+Xvar$6k!fBds@{NWbfC#7^e|11Hnp7*Ia|1LWB z3i@;N-U#6^ujjyGkYi&4+~51e`O8!G`6~N-{kML;{`$HrrMG2&@OH-UgN4HkBSOJyl)8paOr(V z{_sC`wH$wLY!Cdezm>K3uEuk|Z%eoOXV;cpt0%yfUFYH7_c{;1<+b}y{bj0bz5aK8 zqyKyL^S6)pEAtIq$c~h=b!73{buw>UZb*erv7)%nfiC^=RfkkD$6aa&*$sge|L>7 z`z(}w7RufO{~7Orf3=$SkNrhocEreUKVqb;ugd!B|LQ&P$Eyun@;`PYbJ_2 z_F|?Nn|iUe7dv{fyBA-CD02I~;ZT4L+kvT$1CiZtEzfH$k6Tk&AM- z@yofP+$FjQu~FJ8n5IG6a>)8jdjVo&Z5_me(XHGA+^*=GF#S~HT`n{5LUbR@e@u8l zU_9rBOCaW`qap6s?g>1>)r-C#U`zEmM0P){C%k8TmdoL}AX_#*SUd2e5QgC*I|jo& zLhQNn#cR;{4Mty8Xm;e?h2!;8cHU`>;1bI5%xjrCQQRTS(Ps2v^* z^ZB0l=Xsa+ERT5eUku|92>W3;GyG++ytgE7AX_{O!)#5HFNR?Z%dO_+vMKv`)8~4zC@n8AJ1xe$UKWehVVK>goyD$cu9xe2 zx$K?L2gb0TVbRYW5U2#ha3@=D4lHK#l_0l`7rUla^5#&^_DpPV$DQLuB_Ww7qAs1ML2U zEH3ck5-+mc`tk}duJPhpFK+PSHi+!Lf-LU#;vtCa{(*LY-8YcM6A;;b0$F5Pb!0Z@ zI^MI?k=gv~c=N9#v-#JN**xpW>{;0T{a9r4ywICJyN{n8s4Aa?G3>s5EdBzK-KUR5 zHq7qJ$D$zE0d^lg7Hx>^zI!ZQzU`gUSjvlvje-lxv~4> z*#UMZJQlmbFuU`e?Y%m7fZf}UMK+$@%gzq4d)Tqq3&yZ}*4Y7euR2yw@`b{{40$kL z7+By%c#U8Tdj}T6d*D_WX0LCd_Z}$pUY$aC7N{iNbFsR_K5^r%X~KA@0}lvKaMznl zh0%d)%@smr_{6;i!%O*hyfFtLJ{CMC$lP6=CCc0k&VhIzmjQ7ucOgU}z{ZCHl|_TA z6sQKV8pI%XTc8Du?^=tscCS?#;%&9r@c7!5#mnJdcq;dC278QfUwDt@xKKIfi@C7( zco~=DJ=W!VdykE{{@!DAZj|@f2HQKsV;bDyET5ZL?qYmwe$H?oH8#FEJobkr-vqx2 z_khRBeFFYtU;nWMKK8-K$|JCSG`8boAADRi#UH=uPXBQeJ|4!$%9jNF`B(EFTi|0K zd<<}LSkue646ZU)m8-!u=Gt;MaCdXBa-VRYaVNNw9Na`TAO_SxI1mq95U3oe9;g+l zA7~tC7RU*-3v>zG5a=DaIWRsjH83kMH}G)a@xU{I7Xz;a-VE#wd>r^H@MAy=UJ$$_ z*d};Wa9Hrx;H=>C;OgKj!L7la!9&47nwVy%rKeq(Rx531+U~Ru(mqZ5HtlrUFKIkq zp0C7T!DsT#_zrwGK9}z=j1y)Ej|i)UkA!c9AB7-%qkuaB!jbj@{3pVHDyPGL2K;Bj zmeGQ>vbl0xn7asG+iEbTI_JPQfpo4R7vnNv%^SmagsWhxW-wKA*z#m^6}Z;ih0q5T zx%ONot`lTl2k(O$pm%z4Rp1r8ge&4Mg)MVcZWzpQB=p_QX%A&UG+8_wUI1~s7oQRq z!SJ^cHvW2VINOV#r7eXq?|SiOZ8;2&Gg*wvD=FIE@Q)H3vr}Mkj~DlAzkQnLy}7YC zLu1jFS^QCA@nDd}>m3#cdNJy?{7IGT%Vp8;Ra^d_$FNuGk&ypf=Z9xFufg~Y%In^Ie(!kpy3df= z92R)-+>-2oF+WNy?i5(uuXk7+=*4rrx*NvWGK)V- zEFKK9c)i2oKrcqUp0wrt-ZU&mz230pL*5t`qw@c6?flPI5RT^;;D4Eu;PV!O7~~Xq z48W%?1j9N!2H+E?!mter!spF|7y$+0GY2;vg-@LWF#|qza1IH4=7QW1cnolZAqJt^ zRDj{TAO^X6;L{i6?uE}@5Gwq|5NE>YF38P-PaVu5Pz_?az-1822WmpB5U2(5fX6^KG+iC zwZT>pI|N%p>=RPo7NxV?P&ucj!PR1@#nOm zFz25j!dmksFq{Dq)}0>?u>wC5;#7V#jGqEA$W7yKg?J}_8^n|R?GR7#;~}2rCqnEk z+yPVOLWE}&roiwRi156^G>Eqg(;*%f?uPN7LJV?8gnJ<#6=p)bModC%BhH4{R=gkL zD)9lBay7&tw?>=?afdh`#=HqJ$h{>#0`YBeA;fpY#~>!8#n4(CVvwsNErD29dII7V z(o+y;O3NY6lAeZ`l%9onpR@|%*U}n@-$>6x{8oAqA}_CnD9Gy}it;NEC3z!6S$+*- zNZt%_p8Pt*hvaP#=gZq6J}kcp@e%oLhzsPM5EshtL97|t4e|2OUWm0q`ynPm??bE| zIs~y!=tGEgLmxwYDfB7CwV@*r*M&ZV*g*LlVngLG5Hpo8AudzCg1B7y2I2}O1@UR+ z6t{p|0`H4;g4QR<&F1)V>@VTc|3JRLxvR&9@J&<-~lB#)}O5Ppkcpq zi^0Qh8c+bE>OrDEN#|k3h2Ff*k7`knUpO#tz^^9D9xynM&FlPBl-Pjgg-dmQg#Y~K zP0!zua%eW^N8xPFk2t?T=f|B}pz~w=Cp&L?vdq7Ivh$h`Qu4z7dDPW*&VaYIfDCpz$ISdSd*Q_>|dsD%n{C)%Tiu{DtT4Z6adF=0)`JR%bs0URpmX6Z1x@N) z!F3r73tRsRu5r7;eTEMxxRPt!p}25F-mrq!1BVPK7+5ffr4Am{qF`8F;ee7WxsqYU z&A7e=!*bi_wdY3U4H#aKo6F@7FD`~Do1N>d7J0++IO;l2oePF}k9}BE=g}p@3I<-@ zeDHt)1>P%Aa(SzQK?TKy`E2F6rhWQ&PtkHf-jI@lK3waP_JfPzJr0ZPVfetC3W~1- z`;)aU@rMTw$!%6RY-C|cLDNBfxGu$o16#sl^L}}Q`WBRQC@Ah+kUtnkbQ(OI#eyLN z^70GVyoV1MaBXq7eucvd;9UWuS`~Ob)O>IsZ#XBfq@Op;*1Fr^;*tW^e@#ae6zBCV z@RqY#!LVTk#ihrVcuz(Bac<(93yVw6_tLqs@Oyi!lnuAroZJz;J^ zaq-~dbAsHQ!6VxZ&+q3i1gvI0d(B|N)`Lb2?q9$PhyU5a5`t)7FtX*Kd_7}lzI@bDpC!jQl6h`eHNeC{B&EVweA{I&I7;cEx^uXMY@LBmTJSRH9w2m{Rr z{J-|DF1C&AI$!<|DU$KX*`#TuhE@K&XjZm&?Z#`++2vaDN{D2uD|)?KD3vI3Br&E) zW`>ll#*3(^3;3Z0_CXISAfQgMc`J$lZC_dhMUkRGQJ_U1inc(Cz6C{Jg1!`eO8R~0 z+?gR|$=LwuQzBaD+~0H0`R=*r-Wko%UcS| z4#kg5v$u=-c7PoLdSfYd21DO7?d@*Q_ii=Yz2(A+S@|~Bo;E~Z8c!|GSu??xR_?PJ0kNfuhV!asUWTo z6qdO z=6fBRU}JcSmUg`dnvl}QL)&+c4gfdW?d^Fc3U6kq5eyc)E$`u-Edw1v$GvgZ0t-jr zde;4T>~LUoW!oC4Xj2^iR-+SmBl)^N46}CSOPsYWw8&=aJ)2k^ZU%A+;i%k??dX!! zu_bw8@dc+A!kT@lfajUrVA~A5U=XYhdi{HiL3772^*~a~jlqr?^ahR2y><&pnscv> zX!Rh@FL~W-tqjnNCJIe^BwJm%_6whMt`g@f1t_U=2x&(eMHJA zmK!e9#crI3_r#gVYNBEfCl;VEXCtrf|5jNWamUKAarx>P@m8vV%x;I+yXL<-Y;?fy zY<>kXR&(R=W)=Hphc>hs0$_+ee$KW~teYPXrElOgs)l1JZDZ{Sz>CUZZQUmA~nG2xNX8+c&dI z*#0DqgM{54>)4BUjx*epB(dCRcg=lof88H;R}sacd8uu)W*5H@HP_y2GlYf57Q3V% z20PZBty;g|X*b0J(}Fv;yP6II@SF`^;mUlo)7#|PL|Z{VR>;6_$d(rlVRyi>?J(^B z7EXV0rDl#bxl8?x=HK(Dd8d;Mw_>`JC?u z?G9zj0+x6uJCE!i4d1Kxkm~P~={Cfejw0FCaI%#whx`rCXB(<_w=beKQ}6Z7dW1U8 zR2^@rhq7qSK0KdB}>Ct#NQXol$bm1pP*F|h1kH=1C7P%}M11ze&b_@A_n25{? zmK$9h*LZv)vP)!`ng0QXKGjWFJ z4$Z^0zt?Vhfjw^kMqE%J+tlN?xjW#t+C~WkMW?|)&o4X}1$J@ZkRROHVvr4Dx6v$& z;$|FRi+gBObVlpPJR0%pI55~u)Bw9OYB-SW2W@LqyLlgK@eCloAKcs-c2Oe1GoZ8M zN~imbo%0U|UYAiLsu{U@u?uPyfn#t-R$u^+qm>Y7&u#H)8yh{gam0mHQ%-4MVAHOq zEaVGb2W}$BGRiP{!Vv@Og8|(DJ``C6bmrRI;|07LwuQWsz@fwDnkO#mESNe?bp*z+ zz+SY3S*Xd{z%Y>RFC&n&aa3LG_J=5IE5mY>>&+o>?=}%xfGRyU+?}K(JYNAu$={b| zGROAntv29%Ayyk*W=2n-+;HV4fZcgDt^2N~?dq2694*luG@31)3=^$Vn?C_GuCZX1 zty{qrfwwhas3Bk7X=~;!oIPv~O(e%QyuNNX+tPmip-nFa0=^MXqV~8rw?;6fCNO1# z1+MY9vrBh#` zm(jLl-7agJWfz(Akq)Ez^#L8iRyI_qjXv07WzxetW8vKoId8~G42R@^Co+H?AQC>~ z?6(@hvxPiZo?5{|$UA#a;hi8GiZoDR0W+}0A+~U=~t^&PG z7H{F*4c-a4<@a{A0E<);ZF-Xgw=l}q5$F&?semMX-Rj@y4FejK@M;n#YVRSCMyQtiEpiD3Z({_~G_AyPlq+Cz zEI?lKGYLb+mN4#BjIL;&%;@4bIH61-aw0%-xl53I~h*vt0R@H6;Ylk3K`>!`#2B;`clqOIqci&Fjo z2zT(Q2m<%fo-$rWTjD*gJ?El=77eK(GAbR<0<2e1vmSlMbL*%ZuhkMQWeroKEhuR; zZyFWzC~8wNYa=&AP)8-S6vQhP5(IqJ{8Ymt1lPfJO|-|-Q~d&Cy7Jj6&X7{_zmx=?o9GAxM^)gC&+ zsJ5ZTl+SYIq(nEarLA$Dw$xGLQuZ(jb8iJ6PQT)MS(Vj}Th2&h8wT~wP`r@qts&8Y zHM-()tdzB(F##8kC=b`QSsj(jHObY|vwgWH>H91T$6-_%Vm$i1mWAVR{dG}iO7q}N ztR!6EA|`NsfPX|wmt=h-cI7)^%GH`%SZ_V(inbG5ar(U0&Y^CIsMf(KrqmkEy%4rw z^k|E19gNpP%aOd5GZsHfi~>4Z+ZI;R5G5ub&flnvs0^#x$A`VSdzy=<#gnsR zi22o7^qMyhF=8Luwjqg;g|UROE?ylYl~-73oJ<__ph&}Ed>@C4et zF<%(%^Ro1L1Le2TZUODs>PzS~XYL|ZgN#M=zir0HdgaW1D>BL|B-ZgT+BXUiRRLU7 zMvs{B7Q~=E5CgcS%)pEpa5_!g=7HpS3}rnxyFF=Jr z_+2V@4^FJYaXsXPUabGak6DCinJaKY$ge!}?+xCbVZ=;V7OgMZ6 zCuN=sb;qPfQ;mP28jEs>#w7wY<}e+xxB{9d4|+0}XMwcZPC3glm7I z$W6TmhvA_hzyp~T$Whr%NavEGqJ2o=u~*IAMT#Tym`jv-9M>A$azoh#NTSQpAR3{^ zYaWf+O2Ocvmm|Ii!~XEYO@8oWCLi}&%x^&`T|_6JYUo^rCmL-L!Z3RF4qcDt^2D<* ziVO0~svl)gB8{h;g>aC^*G4Dd8@MgcO~Lqr>ogVUV?K-skG4F}(z`>$IiUmma>0#9l|7l{HmDvQ&zj_L z3IWf-cZnzik^0c6cj-V}UZF7>A^6@77h1f7oo&#`>qng%m8V{GQfV5-nRq@7;dQz0 z8ZacUK86&o%jL?xv?n0h9cQsFlXd!92>tW4$~eaS zA>9A)JmM$f(woqMc#>y~csdAJ=A7(GAylErz zWn5}pGM_<-)>0b}T5O4fwXG(Y(&qDkVvy)S^0>EC^R_s^xE37LN6oPHX)WW+#jw@$WsV-c&uTe(i5W{h zZFJRh{DSLri^eZWL#fY`IeH0us?66;J8)}Aq2K=4i}jDs!_(-u^cK#yo)Jtcz=6AO z%r9}pFd#9+g+bA_dG+?lsf4|`FexK$&vh``iavv*{43mwZ=yFZ9=Lw!WqQkyXy`=% z+gyep@&f#lNvyst>q*i6oQ(B`^kqN|Z)k9I9>;EqjQAi|gI#^GVKhu9zWnT2b@Zea zZgjfYo;+tUDCRwG{-K!J19Fv7YsZ@l7LN=G2E>Gii z(^R=UHC4*xoO0Q%xiuD|-pN$(nheJ(WlX}Y;muGqESHffxV02+Diw3-7bX`I6zU{1 zCW*?d7Gz$SoKHYNB5@uX8;oxt&m;c9&UmgQHCSLLPOK2j6fHz6m>= zBvf+`j+1Qrj?gus8$w%2v?*wtr&6*bv?H`Hbig)6ZF3|gOF~zK)>&K9+CwRMUFe+9 z1);TMmR7qpG2Rg%krU0{mlju&K($64uSvd|%;hp=$4Mshxy6^^n=rk|G)+*M%R=B;V=>wPPtR( za?UiQ%ZGWL@u_020JY&dWyk?ms22sNrlzvFG%AvXTz2vtnoO4gM-~alhlY*_A!Jkl z4pROIN1y{q6SS(pK~wI*Z^NBX2xS~`a|aTW+8q;#Npf;2_Xp>!FnUZH8MqgjJ@;v89{SScyQ<`NY05(A0 zsiYIEbAU{;?0z*@NhQn4$svH7+(!m2+^?d}L0wj|Xo>iNC67Y*5`?561ntm}Wo1SP zh-7Cgm>gAQhvOz?dfwxFxbLAm+oOsr1u{rESqONkLM27Vbl@x53YH0FGPtE2tx2&a zuSHR+EUmG=C<{|QBo%G2@*Fr>j>90yuqp&DiRB3&nsyKzrs-6g$82)F(yga6sHTr4 zK+!0Jz$%5M>mK}Z9zHU8Ve*0?nwWGj3zEkS zCnn*!m@RlEOUoFVAWfbl#RgF^@M1H~#fpv-2F~Wla0n+Uq$e+6|0p@!i!i}yP;Mxg zCzzbda%*x@nBfEh2y{e1OiaGZxQLOaRDyezeX#*zNnh1{3SywDfh+2`=TMMj0p}ZA zluRoF1d`kiu7Fh#5H!R{$kAAX3dGeU8(4ltw~s5Vzs3*B(ec`Z1s)7Nz+F!w_3K&wDfE85%gS05= z384j{d7+NboY1V$jL@`Og|{-UC+NrS>r9qPL`C911}&jb#(te9NjX}gl#S;2kw$a0 ztmMwoGB8>OM$5ox85k`Cqh(-eWfYE_;-u0bS8)<)$SF=D4LQY0q#>s`%_&ZE7Nt9i!|ia=mj-;!5S@6Q7J|fbfMSH2~!zpVVEErg9vRrYp3n z=&leWFj@shjKF9W7%>8)Rba#jOl3n5vPoCOfa%H+G00I2n1Ul>kW+A06r2?c&Wd`( zimaR(8qtSIIj%`e2rUTB3w4C%gl2_igr+enu&DDRiq_S@x*Awl1M6yFT@9?Ofps;o zt_IfCKotXlI{P99Ih}nGgPa;DVvth<>uO-#8dz5Y>oQ+;Yi3={BrT#F%_J=d%?ove z=7eU2W`w5QI?a5CADHR5?JFy5 zqcO5ccTH_y)5%>^+oeD1)OP8QoZ24s*RZ&zwy)9l3ACY!qXOi+ z+oCBu{J@lgyQ7NjaF>>HG({mO>X_~n*g-BYq(g@t3T}rGfYEj^S^`G%z-S2=7bm)^ zU15$LP^hL$2jnOWOqIY`7M`%uHR%k|O8d`{%Y*dn>B1A&#K0l&MU$yS5 z)_v8wuUhw2>%MB;SFI%n2{xx%O9vF{EQ&DXRBMcc;gJKKkaR(4UZ^89Cp0TGBQ#C@ zI7RGS5?XZo)P2B@=sr;02deu(bswni1J!+?x(`%a$w7k6sqWGNg{r#pe^i=k{@_Zu{`d7ix4jwf$&p1ehMz0ScHwgTI00`=S;$q|ysWMhPBnuC+F5bi|= zUnPT+lEDMX;G|>-kn|c9(`|$ml}#usD9bCuD4g~)Zy~ml0g*^1w-AeD<}Jh`nRyGbNM_zb zd}uEv4-PHFhYIGQf_bQ59x9lJ3g)4Ld8l9>DwtFim_nXld#F=$C=&*V4;5lEKuiXR z$pA4KASMIEWPq3q5R(C7GC+JN&>p!5{0B%N>WI*i6995TOHKgD2`xDRASblsgqGYw zY9#_1kw|VK6^YDSNJS#^7E+POyoK~Ag!ITldZdsZDWpdV>5)Quq>vsdq(=(rkwQup z0V(9cdT@pGD1`I~rSJ(du}>gn4v>-oQZhhF21v;ODH$Lo1Efa+=`n7E;~yYF^J5xH zPUy&KC^?}cXApqFwg*#op&whwj_pDhNvyXET_iDY7y7Y<>^Ow%*g|%!kR2;z#|qi8 zLUyc>9V=wV3fZwjcC3&=9<0MS3YkcQza66x;E(|vGO7SW5XcD*IYA(&Cju17lZSchU(%1|7F3bT zJnr8~KO~_TsG{{$(R!*dJyp=2Dq2q!t*43>M`AyV)>B36DX|Ay6iW5LfEF3hB7-ZD z0WC71MFzBBzo5k|&>{m`PqVVMe!#6M1xxXlgXt7B$KNjSFWmV)AO_6SCapquZ9vA| zn>+IdsSCItcfmOLEvGNwk3MiA+^IvVhN2RFi})?199Hv>3l3`>)HtYd(9tmkCxLH# z;?FN9Oafne^s#$>qkp^Cja~t*@A$n3K?3b^yzObO;;ZClZ_n3n;!6W+{r>0eJFPeN zUYWfN0p*WIZ}r=^wdDH_K92w5@|0IaO(9`2^1T5#pJB#1`{x|>NAO7xpU#E&YsTvR?t4~mU~~OXfAh2dvGASi z|9vw#^|#-H{o&95FkK0AjwXwJ-(wz ze-Q)l?R=UB`}xn$1OiD}M-@DN#c!5e0UtM;;l$t@7@sX?y91K3A8o($OckXV^Jj3d z_Yach({wcZ^Xb$Tq~6B!wCkY!1OBRgB6c18HooQYjIPmFG{)LB+5b@{JhP~=|7=n)!1gMXnC6fl`Tj|GGZVBiVzp?PF zqz!3v36D$Y=Ze`x%0Tz?=*x#9^i46o=W!cj@IfH{sAlnFa{7?P_#;hhcU$Cye zAK~F6WkXxj75FnfI9jSm*<<6>v`QT+ercarA6 zMx6TxfB9F{*B$jhTHf zn0f7sr9!DtZP>5#sX#)2TgmV}19%1bLrQ%mlv=@0EC(BCQ_cWO z-k#T~bVzT^Gy?s$EPtjlY}cB2-4`%!@!N8&Q6l8xDcXdpUmVlDdNBe44XPKz8N#a< WKlL93D}05aaTs=g{_``3!2bbQ3UAl| literal 96256 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 z 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 k&NNN{!NQqg58R;e9DW9JA Date: Sat, 19 Dec 2020 01:08:09 +0200 Subject: [PATCH 39/53] Changed Solution folder's name --- Benchmark/{Solution (Not very organized) => Solution}/.gitignore | 0 .../Variable-Encryption.sln | 0 .../Variable-Encryption/Benchmark/BenchmarkData.cs | 0 .../Variable-Encryption/Benchmark/BenchmarkPreset.cs | 0 .../Variable-Encryption/Benchmark/BenchmarkPresetGroup.cs | 0 .../Variable-Encryption/Benchmark/BenchmarkResults.cs | 0 .../Variable-Encryption/Benchmark/BenchmarksManager.cs | 0 .../Variable-Encryption/Benchmark/ChoosingState.cs | 0 .../Variable-Encryption/Benchmark/Program.cs | 0 .../Variable-Encryption/Benchmark/TestLibrary.cs | 0 .../Variable-Encryption/Benchmark/TypeInBenchmark.cs | 0 .../Variable-Encryption/Benchmark/Utilities.cs | 0 .../Variable-Encryption/Benchmark/VarEncBenchmark.cs | 0 .../Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs | 0 .../Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs | 0 .../Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs | 0 .../Variable-Encryption/OldTypes/EncDouble_0_5_0.cs | 0 .../Variable-Encryption/OldTypes/EncDouble_0_8_0.cs | 0 .../Variable-Encryption/OldTypes/EncDouble_0_9_0.cs | 0 .../Variable-Encryption/OldTypes/EncFloat_0_5_0.cs | 0 .../Variable-Encryption/OldTypes/EncFloat_0_8_0.cs | 0 .../Variable-Encryption/OldTypes/EncFloat_0_9_0.cs | 0 .../Variable-Encryption/OldTypes/EncInt_0_3_0.cs | 0 .../Variable-Encryption/OldTypes/EncInt_0_7_0.cs | 0 .../Variable-Encryption/OldTypes/EncInt_0_8_0.cs | 0 .../Variable-Encryption/OldTypes/EncInt_0_9_0.cs | 0 .../Variable-Encryption/OldTypes/EncLong_0_3_0.cs | 0 .../Variable-Encryption/OldTypes/EncLong_0_7_0.cs | 0 .../Variable-Encryption/OldTypes/EncLong_0_8_0.cs | 0 .../Variable-Encryption/OldTypes/EncLong_0_9_0.cs | 0 .../Variable-Encryption/OldTypes/EncString_0_5_0.cs | 0 .../Variable-Encryption/OldTypes/EncString_0_7_0.cs | 0 .../Variable-Encryption/OldTypes/EncString_0_8_0.cs | 0 .../Variable-Encryption/OldTypes/EncString_0_9_0.cs | 0 .../Variable-Encryption/OldTypes/EncryptionTools_0_3_0.cs | 0 .../Variable-Encryption/Types/EncBool.cs | 0 .../Variable-Encryption/Types/EncDecimal.cs | 0 .../Variable-Encryption/Types/EncDouble.cs | 0 .../Variable-Encryption/Types/EncFloat.cs | 0 .../Variable-Encryption/Types/EncInt.cs | 0 .../Variable-Encryption/Types/EncLong.cs | 0 .../Variable-Encryption/Types/EncString.cs | 0 .../Variable-Encryption/VariableEncryption.csproj | 0 43 files changed, 0 insertions(+), 0 deletions(-) rename Benchmark/{Solution (Not very organized) => Solution}/.gitignore (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption.sln (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Benchmark/BenchmarkData.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Benchmark/BenchmarkPreset.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Benchmark/BenchmarkPresetGroup.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Benchmark/BenchmarkResults.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Benchmark/BenchmarksManager.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Benchmark/ChoosingState.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Benchmark/Program.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Benchmark/TestLibrary.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Benchmark/TypeInBenchmark.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Benchmark/Utilities.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Benchmark/VarEncBenchmark.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncDouble_0_5_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncDouble_0_8_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncDouble_0_9_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncFloat_0_5_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncFloat_0_8_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncFloat_0_9_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncInt_0_3_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncInt_0_7_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncInt_0_8_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncInt_0_9_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncLong_0_3_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncLong_0_7_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncLong_0_8_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncLong_0_9_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncString_0_5_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncString_0_7_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncString_0_8_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncString_0_9_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/OldTypes/EncryptionTools_0_3_0.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Types/EncBool.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Types/EncDecimal.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Types/EncDouble.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Types/EncFloat.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Types/EncInt.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Types/EncLong.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/Types/EncString.cs (100%) rename Benchmark/{Solution (Not very organized) => Solution}/Variable-Encryption/VariableEncryption.csproj (100%) diff --git a/Benchmark/Solution (Not very organized)/.gitignore b/Benchmark/Solution/.gitignore similarity index 100% rename from Benchmark/Solution (Not very organized)/.gitignore rename to Benchmark/Solution/.gitignore diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption.sln b/Benchmark/Solution/Variable-Encryption.sln similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption.sln rename to Benchmark/Solution/Variable-Encryption.sln diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkData.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkData.cs rename to Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkData.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkPreset.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkPreset.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkPreset.cs rename to Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkPreset.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkPresetGroup.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkPresetGroup.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkPresetGroup.cs rename to Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkPresetGroup.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkResults.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkResults.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarkResults.cs rename to Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkResults.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/BenchmarksManager.cs rename to Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/ChoosingState.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/ChoosingState.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/ChoosingState.cs rename to Benchmark/Solution/Variable-Encryption/Benchmark/ChoosingState.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Program.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/Program.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Program.cs rename to Benchmark/Solution/Variable-Encryption/Benchmark/Program.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/TestLibrary.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TestLibrary.cs rename to Benchmark/Solution/Variable-Encryption/Benchmark/TestLibrary.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TypeInBenchmark.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/TypeInBenchmark.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/TypeInBenchmark.cs rename to Benchmark/Solution/Variable-Encryption/Benchmark/TypeInBenchmark.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/Utilities.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/Utilities.cs rename to Benchmark/Solution/Variable-Encryption/Benchmark/Utilities.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/VarEncBenchmark.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Benchmark/VarEncBenchmark.cs rename to Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncDecimal_0_5_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncDecimal_0_8_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncDecimal_0_9_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_5_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncDouble_0_5_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_5_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncDouble_0_5_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_8_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncDouble_0_8_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_8_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncDouble_0_8_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_9_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncDouble_0_9_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncDouble_0_9_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncDouble_0_9_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_5_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncFloat_0_5_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_5_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncFloat_0_5_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_8_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncFloat_0_8_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_8_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncFloat_0_8_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_9_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncFloat_0_9_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncFloat_0_9_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncFloat_0_9_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_3_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncInt_0_3_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_3_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncInt_0_3_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_7_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncInt_0_7_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_7_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncInt_0_7_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_8_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncInt_0_8_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_8_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncInt_0_8_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_9_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncInt_0_9_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncInt_0_9_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncInt_0_9_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_3_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncLong_0_3_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_3_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncLong_0_3_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_7_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncLong_0_7_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_7_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncLong_0_7_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_8_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncLong_0_8_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_8_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncLong_0_8_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_9_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncLong_0_9_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncLong_0_9_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncLong_0_9_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_5_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncString_0_5_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_5_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncString_0_5_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_7_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncString_0_7_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_7_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncString_0_7_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_8_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncString_0_8_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_8_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncString_0_8_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_9_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncString_0_9_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncString_0_9_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncString_0_9_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncryptionTools_0_3_0.cs b/Benchmark/Solution/Variable-Encryption/OldTypes/EncryptionTools_0_3_0.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/OldTypes/EncryptionTools_0_3_0.cs rename to Benchmark/Solution/Variable-Encryption/OldTypes/EncryptionTools_0_3_0.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncBool.cs b/Benchmark/Solution/Variable-Encryption/Types/EncBool.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncBool.cs rename to Benchmark/Solution/Variable-Encryption/Types/EncBool.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs b/Benchmark/Solution/Variable-Encryption/Types/EncDecimal.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDecimal.cs rename to Benchmark/Solution/Variable-Encryption/Types/EncDecimal.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs b/Benchmark/Solution/Variable-Encryption/Types/EncDouble.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncDouble.cs rename to Benchmark/Solution/Variable-Encryption/Types/EncDouble.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs b/Benchmark/Solution/Variable-Encryption/Types/EncFloat.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncFloat.cs rename to Benchmark/Solution/Variable-Encryption/Types/EncFloat.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs b/Benchmark/Solution/Variable-Encryption/Types/EncInt.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncInt.cs rename to Benchmark/Solution/Variable-Encryption/Types/EncInt.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs b/Benchmark/Solution/Variable-Encryption/Types/EncLong.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncLong.cs rename to Benchmark/Solution/Variable-Encryption/Types/EncLong.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs b/Benchmark/Solution/Variable-Encryption/Types/EncString.cs similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/Types/EncString.cs rename to Benchmark/Solution/Variable-Encryption/Types/EncString.cs diff --git a/Benchmark/Solution (Not very organized)/Variable-Encryption/VariableEncryption.csproj b/Benchmark/Solution/Variable-Encryption/VariableEncryption.csproj similarity index 100% rename from Benchmark/Solution (Not very organized)/Variable-Encryption/VariableEncryption.csproj rename to Benchmark/Solution/Variable-Encryption/VariableEncryption.csproj From 7108ebf14f1d2f91d47a56919c7adb9e3e6b71ae Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 01:09:08 +0200 Subject: [PATCH 40/53] Updated EncTypes in main folder --- EncTypes/EncBool.cs | 13 +- EncTypes/EncDecimal.cs | 70 ++++++++--- EncTypes/EncDouble.cs | 62 +++++++--- EncTypes/EncFloat.cs | 40 +++--- EncTypes/EncInt.cs | 193 ++++++++++++++++------------- EncTypes/EncLong.cs | 272 +++++++++++++++++++++++------------------ EncTypes/EncString.cs | 62 ++++++---- 7 files changed, 435 insertions(+), 277 deletions(-) diff --git a/EncTypes/EncBool.cs b/EncTypes/EncBool.cs index c26b159..f4db616 100644 --- a/EncTypes/EncBool.cs +++ b/EncTypes/EncBool.cs @@ -8,13 +8,17 @@ public struct EncBool /// You thought you would need an encrypted bool. /// You're a failure as a human being and a waste of life. - #region Variables And Properties + #region Variables readonly bool _value; + #endregion + + #region Properties + public bool Value { - get => Decrypt(_value); + get => Decrypt(); } public static string FalseString { get => Boolean.FalseString; } @@ -34,9 +38,10 @@ static bool Encrypt(bool boolVar) { return !boolVar; } - static bool Decrypt(bool boolVar) + + bool Decrypt() { - return !boolVar; + return !_value; } public int CompareTo(Boolean value) => Value.CompareTo(value); diff --git a/EncTypes/EncDecimal.cs b/EncTypes/EncDecimal.cs index 26088a0..0aec94f 100644 --- a/EncTypes/EncDecimal.cs +++ b/EncTypes/EncDecimal.cs @@ -3,19 +3,19 @@ public struct EncDecimal { /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an deciaml. + /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted + /// The encryption will happen in the background without you worrying about it + /// In the memory it is saved as a an array of weird bytes that are affected by random values { encryptionKeys array } + /// Every time the value changes, the encryption keys change too. And it works exactly as a deciaml. /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties - // The encryption values - private readonly decimal encryptionKey1; - private readonly decimal encryptionKey2; + private readonly int[] encryptionKeys; // The encrypted value stored in memory - private readonly decimal encryptedValue; + private readonly int[] encryptedValue; // The decrypted value private decimal Value @@ -23,31 +23,56 @@ private decimal Value get => Decrypt(); } - public Decimal MaxValue { get => Decimal.MaxValue; } - public Decimal MinValue { get => Decimal.MinValue; } - public Decimal MinusOne { get => Decimal.MinusOne; } - public Decimal One { get => Decimal.One; } - public Decimal Zero { get => Decimal.Zero; } + public static Decimal MaxValue { get => Decimal.MaxValue; } + public static Decimal MinValue { get => Decimal.MinValue; } + public static Decimal MinusOne { get => Decimal.MinusOne; } + public static Decimal One { get => Decimal.One; } + public static Decimal Zero { get => Decimal.Zero; } #endregion - #region Methods & Constructors + #region Methods And Constructors private EncDecimal(decimal value) { - encryptionKey1 = (decimal)random.NextDouble(); - encryptionKey2 = (decimal)random.NextDouble(); - encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + encryptionKeys = EncKeys(); + encryptedValue = Encrypt(value, encryptionKeys); } // Encryption key generator static private Random random = new Random(); + private static int[] EncKeys() + { + var arr = new int[4]; + for (int i = 0; i < 4; i++) + { + arr[i] = random.Next(); + } + return arr; + } + // Takes a given value and returns it encrypted - private static decimal Encrypt(decimal value, decimal k1, decimal k2) => (value + k1) * k2; + private static int[] Encrypt(decimal value, int[] keys) + { + var valueInBits = decimal.GetBits(value); + for (int i = 0; i < 4; i++) + { + valueInBits[i] ^= keys[i]; + } + return valueInBits; + } // Takes an encrypted value and returns it decrypted - private decimal Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + private decimal Decrypt() + { + var decrypted = new int[4]; + for (int i = 0; i < 4; i++) + { + decrypted[i] = encryptedValue[i] ^ encryptionKeys[i]; + } + return new decimal(decrypted); + } // Overrides public int CompareTo(Decimal value) => Value.CompareTo(value); @@ -204,6 +229,17 @@ private EncDecimal(decimal value) /// assign public static implicit operator EncDecimal(decimal value) => new EncDecimal(value); + public static explicit operator EncDecimal(double value) => new EncDecimal((decimal)value); + public static explicit operator EncDecimal(float value) => new EncDecimal((decimal)value); + public static implicit operator EncDecimal(ulong value) => new EncDecimal(value); + public static implicit operator EncDecimal(long value) => new EncDecimal(value); + public static implicit operator EncDecimal(uint value) => new EncDecimal(value); + public static implicit operator EncDecimal(int value) => new EncDecimal(value); + public static implicit operator EncDecimal(ushort value) => new EncDecimal(value); + public static implicit operator EncDecimal(short value) => new EncDecimal(value); + public static implicit operator EncDecimal(byte value) => new EncDecimal(value); + public static implicit operator EncDecimal(sbyte value) => new EncDecimal(value); + public static implicit operator decimal(EncDecimal eint1) => eint1.Value; public static explicit operator double(EncDecimal eint1) => (double)eint1.Value; public static explicit operator float(EncDecimal eint1) => (float)eint1.Value; diff --git a/EncTypes/EncDouble.cs b/EncTypes/EncDouble.cs index f5db517..0561a02 100644 --- a/EncTypes/EncDouble.cs +++ b/EncTypes/EncDouble.cs @@ -3,19 +3,20 @@ public struct EncDouble { /// A struct for storing a Double while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an double. + /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted + /// The encryption will happen in the background without you worrying about it + /// In the memory it is saved as a an array of weird bytes that are affected by random values { encryptionKeys array } + /// Every time the value changes, the encryption keys change too. And it works exactly as a double. /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties // The encryption values - private readonly double encryptionKey1; - private readonly double encryptionKey2; + private readonly byte[] encryptionKeys; // The encrypted value stored in memory - private readonly double encryptedValue; + private readonly byte[] encryptedValue; // The decrypted value public double Value @@ -23,32 +24,48 @@ public double Value get => Decrypt(); } - public Double Epsilon { get => Double.Epsilon; } - public Double MaxValue { get => Double.MaxValue; } - public Double MinValue { get => Double.MinValue; } - public Double NaN { get => Double.NaN; } - public Double NegativeInfinity { get => Double.NegativeInfinity; } - public Double PositiveInfinity { get => Double.PositiveInfinity; } + public static Double Epsilon { get => Double.Epsilon; } + public static Double MaxValue { get => Double.MaxValue; } + public static Double MinValue { get => Double.MinValue; } + public static Double NaN { get => Double.NaN; } + public static Double NegativeInfinity { get => Double.NegativeInfinity; } + public static Double PositiveInfinity { get => Double.PositiveInfinity; } #endregion - #region Methods & Constructors + #region Methods And Constructors private EncDouble(double value) { - encryptionKey1 = random.NextDouble(); - encryptionKey2 = random.NextDouble(); - encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + encryptionKeys = new byte[8]; + encryptedValue = Encrypt(value, encryptionKeys); } // Encryption key generator static private Random random = new Random(); // Takes a given value and returns it encrypted - private static double Encrypt(double value, double k1, double k2) => (value + k1) * k2; + private static byte[] Encrypt(double value, byte[] keys) + { + random.NextBytes(keys); + var valueBytes = BitConverter.GetBytes(value); + for (int i = 0; i < 8; i++) + { + valueBytes[i] ^= keys[i]; + } + return valueBytes; + } // Takes an encrypted value and returns it decrypted - private double Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + private double Decrypt() + { + var valueBytes = new byte[8]; + for (int i = 0; i < 8; i++) + { + valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); + } + return BitConverter.ToDouble(valueBytes); + } // Overrides public int CompareTo(object value) => Value.CompareTo(value); @@ -196,7 +213,18 @@ private EncDouble(double value) public static bool operator <(EncDouble eint1, float eint2) => eint1.Value < eint2; /// assign + public static implicit operator EncDouble(ulong value) => new EncDouble(value); + public static implicit operator EncDouble(long value) => new EncDouble(value); + public static implicit operator EncDouble(uint value) => new EncDouble(value); + public static implicit operator EncDouble(int value) => new EncDouble(value); + public static implicit operator EncDouble(ushort value) => new EncDouble(value); + public static implicit operator EncDouble(short value) => new EncDouble(value); + public static implicit operator EncDouble(byte value) => new EncDouble(value); + public static implicit operator EncDouble(sbyte value) => new EncDouble(value); + public static explicit operator EncDouble(decimal value) => new EncDouble((double)value); public static implicit operator EncDouble(double value) => new EncDouble(value); + public static implicit operator EncDouble(float value) => new EncDouble(value); + public static explicit operator decimal(EncDouble eint1) => (decimal)eint1.Value; public static implicit operator double(EncDouble eint1) => eint1.Value; public static explicit operator float(EncDouble eint1) => (float)eint1.Value; diff --git a/EncTypes/EncFloat.cs b/EncTypes/EncFloat.cs index 67f5a75..23778c7 100644 --- a/EncTypes/EncFloat.cs +++ b/EncTypes/EncFloat.cs @@ -2,9 +2,11 @@ public struct EncFloat { - /// A struct for storing a Single while efficiently keeping it encrypted in the memory. + /// A struct for storing a Single (float) while efficiently keeping it encrypted in the memory. + /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted + /// The encryption will happen in the background without you worrying about it /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an flaot. + /// Every time the value changes, the encryption keys change too. And it works exactly as an float. /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc @@ -23,21 +25,20 @@ private float Value get => (float)Decrypt(); } - public float Epsilon { get => Single.Epsilon; } - public float MaxValue { get => Single.MaxValue; } - public float MinValue { get => Single.MinValue; } - public float NaN { get => Single.NaN; } - public float NegativeInfinity { get => Single.NegativeInfinity; } - public float PositiveInfinity { get => Single.PositiveInfinity; } + public static float Epsilon { get => Single.Epsilon; } + public static float MaxValue { get => Single.MaxValue; } + public static float MinValue { get => Single.MinValue; } + public static float NaN { get => Single.NaN; } + public static float NegativeInfinity { get => Single.NegativeInfinity; } + public static float PositiveInfinity { get => Single.PositiveInfinity; } #endregion - #region Methods & Constructors - + #region Methods And Constructors private EncFloat(float value) { - encryptionKey1 = random.NextDouble(); - encryptionKey2 = random.NextDouble(); + encryptionKey1 = random.NextDouble() * 0.001; + encryptionKey2 = random.NextDouble() * 100; encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); } @@ -45,10 +46,10 @@ private EncFloat(float value) static private Random random = new Random(); // Takes a given value and returns it encrypted - private static double Encrypt(double value, double k1, double k2) => (value + k1) * k2; + private static double Encrypt(double value, double k1, double k2) => (value * k1) * k2; // Takes an encrypted value and returns it decrypted - private double Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + private double Decrypt() => (encryptedValue / encryptionKey2) / encryptionKey1; // Single methods public int CompareTo(Single value) => Value.CompareTo(value); @@ -190,7 +191,18 @@ private EncFloat(float value) public static bool operator <(EncFloat eint1, float eint2) => eint1.Value < eint2; /// assign + public static implicit operator EncFloat(ulong value) => new EncFloat(value); + public static implicit operator EncFloat(long value) => new EncFloat(value); + public static implicit operator EncFloat(uint value) => new EncFloat(value); + public static implicit operator EncFloat(int value) => new EncFloat(value); + public static implicit operator EncFloat(ushort value) => new EncFloat(value); + public static implicit operator EncFloat(short value) => new EncFloat(value); + public static implicit operator EncFloat(byte value) => new EncFloat(value); + public static implicit operator EncFloat(sbyte value) => new EncFloat(value); + public static explicit operator EncFloat(decimal value) => new EncFloat((float)value); + public static explicit operator EncFloat(double value) => new EncFloat((float)value); public static implicit operator EncFloat(float value) => new EncFloat(value); + public static explicit operator decimal(EncFloat eint1) => (decimal)eint1.Value; public static implicit operator double(EncFloat eint1) => eint1.Value; public static implicit operator float(EncFloat eint1) => eint1.Value; diff --git a/EncTypes/EncInt.cs b/EncTypes/EncInt.cs index fe2e05d..4aa5dc8 100644 --- a/EncTypes/EncInt.cs +++ b/EncTypes/EncInt.cs @@ -2,9 +2,11 @@ public struct EncInt { - /// A struct for storing a 32-bit integer while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an int. + /// A struct for storing a 32-bit integer while efficiently keeping it encrypted in the memory + /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted + /// The encryption will happen in the background without you worrying about it + /// In the memory it is saved as a weird floating-point number that is affected by random values { encryptionKey1 & encryptionKey2 } + /// Every time the value changes, the encryption keys change too. And it works exactly as an int (Int32) /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc @@ -18,22 +20,22 @@ public struct EncInt private readonly double encryptedValue; // The decrypted value - private double Value + private int Value { - get => Math.Round(Decrypt()); + get => (int)Decrypt(); } - public int MaxValue { get => Int32.MaxValue; } - public int MinValue { get => Int32.MinValue; } + public static int MaxValue { get => Int32.MaxValue; } + public static int MinValue { get => Int32.MinValue; } #endregion - #region Methods - - private EncInt(double value) + #region Methods And Constructors + + private EncInt(int value) { - encryptionKey1 = random.NextDouble(); - encryptionKey2 = random.NextDouble(); + encryptionKey1 = random.NextDouble() * 0.001; + encryptionKey2 = random.NextDouble() * 100; encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); } @@ -41,66 +43,76 @@ private EncInt(double value) static private Random random = new Random(); // Takes a given value and returns it encrypted - private static double Encrypt(double value, double k1, double k2) => (value + k1) * k2; + private static double Encrypt(double value, double k1, double k2) => (value * k1) * k2; // Takes an encrypted value and returns it decrypted - private double Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + private double Decrypt() => ((encryptedValue / encryptionKey2) / encryptionKey1) + 0.5; // Int32 methods - public Int32 CompareTo(object value) => ((int)Value).CompareTo(value); - public Int32 CompareTo(Int32 value) => ((int)Value).CompareTo(value); - public bool Equals(Int32 obj) => ((int)Value).Equals(obj); - public override bool Equals(object obj) => ((int)Value).Equals(obj); - public override Int32 GetHashCode() => ((int)Value).GetHashCode(); - public TypeCode GetTypeCode() => ((int)Value).GetTypeCode(); - public override string ToString() => ((int)Value).ToString(); - public string ToString(IFormatProvider provider) => ((int)Value).ToString(provider); - public string ToString(string format) => ((int)Value).ToString(format); - public string ToString(string format, IFormatProvider provider) => ((int)Value).ToString(format, provider); + public Int32 CompareTo(object value) => Value.CompareTo(value); + public Int32 CompareTo(Int32 value) => Value.CompareTo(value); + public bool Equals(Int32 obj) => Value.Equals(obj); + public override bool Equals(object obj) => Value.Equals(obj); + public override Int32 GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public override string ToString() => Value.ToString(); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public string ToString(string format) => Value.ToString(format); + public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); #endregion #region Operators Overloading + /// & | ^ << >> + public static EncInt operator &(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value & eint2.Value); + public static EncInt operator |(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value | eint2.Value); + public static EncInt operator ^(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value ^ eint2.Value); + + public static int operator &(EncInt eint1, int eint2) => eint1.Value & eint2; + public static int operator |(EncInt eint1, int eint2) => eint1.Value | eint2; + public static int operator ^(EncInt eint1, int eint2) => eint1.Value ^ eint2; + public static int operator >>(EncInt eint1, int eint2) => eint1.Value >> eint2; + public static int operator <<(EncInt eint1, int eint2) => eint1.Value << eint2; + /// + - * / % - public static EncInt operator +(EncInt eint1, EncInt eint2) => new EncInt((int)Math.Round(eint1.Decrypt() + eint2.Decrypt())); - public static EncInt operator -(EncInt eint1, EncInt eint2) => new EncInt((int)Math.Round(eint1.Decrypt() - eint2.Decrypt())); - public static EncInt operator *(EncInt eint1, EncInt eint2) => new EncInt((int)Math.Round(eint1.Decrypt() * eint2.Decrypt())); - public static EncInt operator /(EncInt eint1, EncInt eint2) => new EncInt((int)Math.Round(eint1.Decrypt() / eint2.Decrypt())); - public static EncInt operator %(EncInt eint1, EncInt eint2) => new EncInt((int)Math.Round(eint1.Decrypt() % eint2.Decrypt())); - - public static int operator +(EncInt eint1, int eint2) => (int)eint1.Value + eint2; - public static int operator -(EncInt eint1, int eint2) => (int)eint1.Value - eint2; - public static int operator *(EncInt eint1, int eint2) => (int)eint1.Value * eint2; - public static int operator /(EncInt eint1, int eint2) => (int)eint1.Value / eint2; - public static int operator %(EncInt eint1, int eint2) => (int)eint1.Value % eint2; - - public static int operator +(EncInt eint1, ushort eint2) => (int)eint1.Value + eint2; - public static int operator -(EncInt eint1, ushort eint2) => (int)eint1.Value - eint2; - public static int operator *(EncInt eint1, ushort eint2) => (int)eint1.Value * eint2; - public static int operator /(EncInt eint1, ushort eint2) => (int)eint1.Value / eint2; - public static int operator %(EncInt eint1, ushort eint2) => (int)eint1.Value % eint2; - - public static int operator +(EncInt eint1, short eint2) => (int)eint1.Value + eint2; - public static int operator -(EncInt eint1, short eint2) => (int)eint1.Value - eint2; - public static int operator *(EncInt eint1, short eint2) => (int)eint1.Value * eint2; - public static int operator /(EncInt eint1, short eint2) => (int)eint1.Value / eint2; - public static int operator %(EncInt eint1, short eint2) => (int)eint1.Value % eint2; - - public static int operator +(EncInt eint1, byte eint2) => (int)eint1.Value + eint2; - public static int operator -(EncInt eint1, byte eint2) => (int)eint1.Value - eint2; - public static int operator *(EncInt eint1, byte eint2) => (int)eint1.Value * eint2; - public static int operator /(EncInt eint1, byte eint2) => (int)eint1.Value / eint2; - public static int operator %(EncInt eint1, byte eint2) => (int)eint1.Value % eint2; - - public static int operator +(EncInt eint1, sbyte eint2) => (int)eint1.Value + eint2; - public static int operator -(EncInt eint1, sbyte eint2) => (int)eint1.Value - eint2; - public static int operator *(EncInt eint1, sbyte eint2) => (int)eint1.Value * eint2; - public static int operator /(EncInt eint1, sbyte eint2) => (int)eint1.Value / eint2; - public static int operator %(EncInt eint1, sbyte eint2) => (int)eint1.Value % eint2; + public static EncInt operator +(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value + eint2.Value); + public static EncInt operator -(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value - eint2.Value); + public static EncInt operator *(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value * eint2.Value); + public static EncInt operator /(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value / eint2.Value); + public static EncInt operator %(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value % eint2.Value); + + public static int operator +(EncInt eint1, int eint2) => eint1.Value + eint2; + public static int operator -(EncInt eint1, int eint2) => eint1.Value - eint2; + public static int operator *(EncInt eint1, int eint2) => eint1.Value * eint2; + public static int operator /(EncInt eint1, int eint2) => eint1.Value / eint2; + public static int operator %(EncInt eint1, int eint2) => eint1.Value % eint2; + + public static int operator +(EncInt eint1, ushort eint2) => eint1.Value + eint2; + public static int operator -(EncInt eint1, ushort eint2) => eint1.Value - eint2; + public static int operator *(EncInt eint1, ushort eint2) => eint1.Value * eint2; + public static int operator /(EncInt eint1, ushort eint2) => eint1.Value / eint2; + public static int operator %(EncInt eint1, ushort eint2) => eint1.Value % eint2; + + public static int operator +(EncInt eint1, short eint2) => eint1.Value + eint2; + public static int operator -(EncInt eint1, short eint2) => eint1.Value - eint2; + public static int operator *(EncInt eint1, short eint2) => eint1.Value * eint2; + public static int operator /(EncInt eint1, short eint2) => eint1.Value / eint2; + public static int operator %(EncInt eint1, short eint2) => eint1.Value % eint2; + + public static int operator +(EncInt eint1, byte eint2) => eint1.Value + eint2; + public static int operator -(EncInt eint1, byte eint2) => eint1.Value - eint2; + public static int operator *(EncInt eint1, byte eint2) => eint1.Value * eint2; + public static int operator /(EncInt eint1, byte eint2) => eint1.Value / eint2; + public static int operator %(EncInt eint1, byte eint2) => eint1.Value % eint2; + + public static int operator +(EncInt eint1, sbyte eint2) => eint1.Value + eint2; + public static int operator -(EncInt eint1, sbyte eint2) => eint1.Value - eint2; + public static int operator *(EncInt eint1, sbyte eint2) => eint1.Value * eint2; + public static int operator /(EncInt eint1, sbyte eint2) => eint1.Value / eint2; + public static int operator %(EncInt eint1, sbyte eint2) => eint1.Value % eint2; /// == != < > - public static bool operator ==(EncInt eint1, EncInt eint2) => eint1.Value == eint2.Value; public static bool operator !=(EncInt eint1, EncInt eint2) => eint1.Value != eint2.Value; public static bool operator <(EncInt eint1, EncInt eint2) => eint1.Value < eint2.Value; @@ -111,20 +123,20 @@ private EncInt(double value) public static bool operator >(EncInt eint1, ulong eint2) => (ulong)eint1.Value > eint2; public static bool operator <(EncInt eint1, ulong eint2) => (ulong)eint1.Value < eint2; - public static bool operator ==(EncInt eint1, long eint2) => (long)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, long eint2) => (long)eint1.Value != eint2; - public static bool operator >(EncInt eint1, long eint2) => (long)eint1.Value > eint2; - public static bool operator <(EncInt eint1, long eint2) => (long)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, long eint2) => eint1.Value == eint2; + public static bool operator !=(EncInt eint1, long eint2) => eint1.Value != eint2; + public static bool operator >(EncInt eint1, long eint2) => eint1.Value > eint2; + public static bool operator <(EncInt eint1, long eint2) => eint1.Value < eint2; public static bool operator ==(EncInt eint1, uint eint2) => (uint)eint1.Value == eint2; public static bool operator !=(EncInt eint1, uint eint2) => (uint)eint1.Value != eint2; public static bool operator >(EncInt eint1, uint eint2) => (uint)eint1.Value > eint2; public static bool operator <(EncInt eint1, uint eint2) => (uint)eint1.Value < eint2; - public static bool operator ==(EncInt eint1, int eint2) => (int)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, int eint2) => (int)eint1.Value != eint2; - public static bool operator >(EncInt eint1, int eint2) => (int)eint1.Value > eint2; - public static bool operator <(EncInt eint1, int eint2) => (int)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, int eint2) => eint1.Value == eint2; + public static bool operator !=(EncInt eint1, int eint2) => eint1.Value != eint2; + public static bool operator >(EncInt eint1, int eint2) => eint1.Value > eint2; + public static bool operator <(EncInt eint1, int eint2) => eint1.Value < eint2; public static bool operator ==(EncInt eint1, ushort eint2) => (ushort)eint1.Value == eint2; public static bool operator !=(EncInt eint1, ushort eint2) => (ushort)eint1.Value != eint2; @@ -146,34 +158,45 @@ private EncInt(double value) public static bool operator >(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value > eint2; public static bool operator <(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value < eint2; - public static bool operator ==(EncInt eint1, decimal eint2) => (decimal)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, decimal eint2) => (decimal)eint1.Value != eint2; - public static bool operator >(EncInt eint1, decimal eint2) => (decimal)eint1.Value > eint2; - public static bool operator <(EncInt eint1, decimal eint2) => (decimal)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, decimal eint2) => eint1.Value == eint2; + public static bool operator !=(EncInt eint1, decimal eint2) => eint1.Value != eint2; + public static bool operator >(EncInt eint1, decimal eint2) => eint1.Value > eint2; + public static bool operator <(EncInt eint1, decimal eint2) => eint1.Value < eint2; - public static bool operator ==(EncInt eint1, double eint2) => (double)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, double eint2) => (double)eint1.Value != eint2; - public static bool operator >(EncInt eint1, double eint2) => (double)eint1.Value > eint2; - public static bool operator <(EncInt eint1, double eint2) => (double)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, double eint2) => eint1.Value == eint2; + public static bool operator !=(EncInt eint1, double eint2) => eint1.Value != eint2; + public static bool operator >(EncInt eint1, double eint2) => eint1.Value > eint2; + public static bool operator <(EncInt eint1, double eint2) => eint1.Value < eint2; - public static bool operator ==(EncInt eint1, float eint2) => (float)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, float eint2) => (float)eint1.Value != eint2; - public static bool operator >(EncInt eint1, float eint2) => (float)eint1.Value > eint2; - public static bool operator <(EncInt eint1, float eint2) => (float)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, float eint2) => eint1.Value == eint2; + public static bool operator !=(EncInt eint1, float eint2) => eint1.Value != eint2; + public static bool operator >(EncInt eint1, float eint2) => eint1.Value > eint2; + public static bool operator <(EncInt eint1, float eint2) => eint1.Value < eint2; /// assign + public static explicit operator EncInt(ulong value) => new EncInt((int)value); + public static explicit operator EncInt(long value) => new EncInt((int)value); + public static explicit operator EncInt(uint value) => new EncInt((int)value); public static implicit operator EncInt(int value) => new EncInt(value); + public static implicit operator EncInt(ushort value) => new EncInt(value); + public static implicit operator EncInt(short value) => new EncInt(value); + public static implicit operator EncInt(byte value) => new EncInt(value); + public static implicit operator EncInt(sbyte value) => new EncInt(value); + public static explicit operator EncInt(decimal value) => new EncInt((int)value); + public static explicit operator EncInt(double value) => new EncInt((int)value); + public static explicit operator EncInt(float value) => new EncInt((int)value); + public static explicit operator ulong(EncInt eint1) => (ulong)eint1.Value; - public static implicit operator long(EncInt eint1) => (long)eint1.Value; + public static implicit operator long(EncInt eint1) => eint1.Value; public static explicit operator uint(EncInt eint1) => (uint)eint1.Value; - public static implicit operator int(EncInt eint1) => (int)eint1.Value; + public static implicit operator int(EncInt eint1) => eint1.Value; public static explicit operator ushort(EncInt eint1) => (ushort)eint1.Value; public static explicit operator short(EncInt eint1) => (short)eint1.Value; public static explicit operator byte(EncInt eint1) => (byte)eint1.Value; public static explicit operator sbyte(EncInt eint1) => (sbyte)eint1.Value; - public static explicit operator decimal(EncInt eint1) => (decimal)eint1.Value; - public static explicit operator double(EncInt eint1) => eint1.Value; - public static explicit operator float(EncInt eint1) => (float)eint1.Value; + public static implicit operator decimal(EncInt eint1) => eint1.Value; + public static implicit operator double(EncInt eint1) => eint1.Value; + public static implicit operator float(EncInt eint1) => eint1.Value; #endregion } \ No newline at end of file diff --git a/EncTypes/EncLong.cs b/EncTypes/EncLong.cs index e1b2450..352edbd 100644 --- a/EncTypes/EncLong.cs +++ b/EncTypes/EncLong.cs @@ -2,171 +2,207 @@ public struct EncLong { - /// A struct for storing a 64-bit integer while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an long. + /// A struct for storing a 64-bit integer while efficiently keeping it encrypted in the memory + /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted + /// The encryption will happen in the background without you worrying about it + /// In the memory it is saved as a an array of weird bytes that are affected by random values { encryptionKeys array } + /// Every time the value changes, the encryption keys change too. And it works exactly as a long (Int64) /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties - // The encryption values - private readonly decimal encryptionKey1; - private readonly decimal encryptionKey2; + private readonly byte[] encryptionKeys; // The encrypted value stored in memory - private readonly decimal encryptedValue; + private readonly byte[] encryptedValue; // The decrypted value - private decimal Value + private long Value { - get => Math.Round(Decrypt()); + get => Decrypt(); } - public long MaxValue { get => Int64.MaxValue; } - public long MinValue { get => Int64.MinValue; } + public static long MaxValue { get => Int64.MaxValue; } + public static long MinValue { get => Int64.MinValue; } #endregion - #region Methods & Constructors + #region Methods And Constructors - private EncLong(decimal value) + private EncLong(long value) { - encryptionKey1 = (decimal)random.NextDouble(); - encryptionKey2 = (decimal)random.NextDouble(); - encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + encryptionKeys = new byte[8]; + random.NextBytes(encryptionKeys); + encryptedValue = Encrypt(value, encryptionKeys); } // Encryption Key Generator static private Random random = new Random(); // Takes a given value and returns it encrypted - private static decimal Encrypt(decimal value, decimal k1, decimal k2) => (value + k1) * k2; + private static byte[] Encrypt(long value, byte[] keys) + { + var valueBytes = BitConverter.GetBytes(value); + for (int i = 0; i < 8; i++) + { + valueBytes[i] ^= keys[i]; + } + return valueBytes; + } // Takes an encrypted value and returns it decrypted - private decimal Decrypt() => (encryptedValue / encryptionKey2) - encryptionKey1; + private long Decrypt() + { + var valueBytes = new byte[8]; + for (int i = 0; i < 8; i++) + { + valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); + } + return BitConverter.ToInt64(valueBytes); + } // Int64 methods - public int CompareTo(object value) => ((long)Value).CompareTo(value); - public int CompareTo(long value) => ((long)Value).CompareTo(value); - public bool Equals(long obj) => ((long)Value).Equals(obj); - public override bool Equals(object obj) => ((long)Value).Equals(obj); - public override int GetHashCode() => ((long)Value).GetHashCode(); - public TypeCode GetTypeCode() => ((long)Value).GetTypeCode(); - public override string ToString() => ((long)Value).ToString(); - public string ToString(IFormatProvider provider) => ((long)Value).ToString(provider); - public string ToString(string format) => ((long)Value).ToString(format); - public string ToString(string format, IFormatProvider provider) => ((long)Value).ToString(format, provider); + public int CompareTo(object value) => Value.CompareTo(value); + public int CompareTo(long value) => Value.CompareTo(value); + public bool Equals(long obj) => Value.Equals(obj); + public override bool Equals(object obj) => Value.Equals(obj); + public override int GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public override string ToString() => Value.ToString(); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public string ToString(string format) => Value.ToString(format); + public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); #endregion #region Operators Overloading + /// & | ^ + public static EncLong operator &(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value & elong2.Value); + public static EncLong operator |(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value | elong2.Value); + public static EncLong operator ^(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value ^ elong2.Value); + + public static long operator &(EncLong elong1, long elong2) => elong1.Value & elong2; + public static long operator |(EncLong elong1, long elong2) => elong1.Value | elong2; + public static long operator ^(EncLong elong1, long elong2) => elong1.Value ^ elong2; + /// + - * / % - public static EncLong operator +(EncLong elong1, EncLong elong2) => new EncLong(Math.Round(elong1.Decrypt() + elong2.Decrypt())); - public static EncLong operator -(EncLong elong1, EncLong elong2) => new EncLong(Math.Round(elong1.Decrypt() - elong2.Decrypt())); - public static EncLong operator *(EncLong elong1, EncLong elong2) => new EncLong(Math.Round(elong1.Decrypt() * elong2.Decrypt())); - public static EncLong operator /(EncLong elong1, EncLong elong2) => new EncLong(Math.Round(elong1.Decrypt() / elong2.Decrypt())); - public static EncLong operator %(EncLong elong1, EncLong elong2) => new EncLong(Math.Round(elong1.Decrypt() % elong2.Decrypt())); - - public static long operator +(EncLong elong1, long elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, long elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, long elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, long elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, long elong2) => (long)elong1.Value % elong2; - - public static long operator +(EncLong elong1, int elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, int elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, int elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, int elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, int elong2) => (long)elong1.Value % elong2; - - public static long operator +(EncLong elong1, short elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, short elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, short elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, short elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, short elong2) => (long)elong1.Value % elong2; - - public static long operator +(EncLong elong1, ushort elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, ushort elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, ushort elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, ushort elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, ushort elong2) => (long)elong1.Value % elong2; - - public static long operator +(EncLong elong1, uint elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, uint elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, uint elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, uint elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, uint elong2) => (long)elong1.Value % elong2; - - public static long operator +(EncLong elong1, byte elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, byte elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, byte elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, byte elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, byte elong2) => (long)elong1.Value % elong2; - - public static long operator +(EncLong elong1, sbyte elong2) => (long)elong1.Value + elong2; - public static long operator -(EncLong elong1, sbyte elong2) => (long)elong1.Value - elong2; - public static long operator *(EncLong elong1, sbyte elong2) => (long)elong1.Value * elong2; - public static long operator /(EncLong elong1, sbyte elong2) => (long)elong1.Value / elong2; - public static long operator %(EncLong elong1, sbyte elong2) => (long)elong1.Value % elong2; + public static EncLong operator +(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value + elong2.Value); + public static EncLong operator -(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value - elong2.Value); + public static EncLong operator *(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value * elong2.Value); + public static EncLong operator /(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value / elong2.Value); + public static EncLong operator %(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value % elong2.Value); + + public static long operator +(EncLong elong1, long elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, long elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, long elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, long elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, long elong2) => elong1.Value % elong2; + + public static long operator +(EncLong elong1, int elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, int elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, int elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, int elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, int elong2) => elong1.Value % elong2; + + public static long operator +(EncLong elong1, short elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, short elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, short elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, short elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, short elong2) => elong1.Value % elong2; + + public static long operator +(EncLong elong1, ushort elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, ushort elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, ushort elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, ushort elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, ushort elong2) => elong1.Value % elong2; + + public static long operator +(EncLong elong1, uint elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, uint elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, uint elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, uint elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, uint elong2) => elong1.Value % elong2; + + public static long operator +(EncLong elong1, byte elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, byte elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, byte elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, byte elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, byte elong2) => elong1.Value % elong2; + + public static long operator +(EncLong elong1, sbyte elong2) => elong1.Value + elong2; + public static long operator -(EncLong elong1, sbyte elong2) => elong1.Value - elong2; + public static long operator *(EncLong elong1, sbyte elong2) => elong1.Value * elong2; + public static long operator /(EncLong elong1, sbyte elong2) => elong1.Value / elong2; + public static long operator %(EncLong elong1, sbyte elong2) => elong1.Value % elong2; /// == != < > /// - public static bool operator ==(EncLong elong1, byte elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, byte elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, byte elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, byte elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, sbyte elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, sbyte elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, sbyte elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, sbyte elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, short elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, short elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, short elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, short elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, ushort elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, ushort elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, ushort elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, ushort elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, uint elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, uint elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, uint elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, uint elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, int elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, int elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, int elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, int elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, long elong2) => (long)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, long elong2) => (long)elong1.Value != elong2; - public static bool operator >(EncLong elong1, long elong2) => (long)elong1.Value > elong2; - public static bool operator <(EncLong elong1, long elong2) => (long)elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, EncLong elong2) => (long)elong1.Value == (long)elong2.Value; - public static bool operator !=(EncLong elong1, EncLong elong2) => (long)elong1.Value != (long)elong2.Value; - public static bool operator <(EncLong elong1, EncLong elong2) => (long)elong1.Value < (long)elong2.Value; - public static bool operator >(EncLong elong1, EncLong elong2) => (long)elong1.Value > (long)elong2.Value; + public static bool operator ==(EncLong elong1, byte elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, byte elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, byte elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, byte elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, sbyte elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, sbyte elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, sbyte elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, sbyte elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, short elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, short elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, short elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, short elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, ushort elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, ushort elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, ushort elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, ushort elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, uint elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, uint elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, uint elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, uint elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, int elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, int elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, int elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, int elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, long elong2) => elong1.Value == elong2; + public static bool operator !=(EncLong elong1, long elong2) => elong1.Value != elong2; + public static bool operator >(EncLong elong1, long elong2) => elong1.Value > elong2; + public static bool operator <(EncLong elong1, long elong2) => elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, EncLong elong2) => elong1.Value == elong2.Value; + public static bool operator !=(EncLong elong1, EncLong elong2) => elong1.Value != elong2.Value; + public static bool operator <(EncLong elong1, EncLong elong2) => elong1.Value < elong2.Value; + public static bool operator >(EncLong elong1, EncLong elong2) => elong1.Value > elong2.Value; /// assign + public static explicit operator EncLong(ulong value) => new EncLong((long)value); public static implicit operator EncLong(long value) => new EncLong(value); + public static implicit operator EncLong(int value) => new EncLong(value); + public static implicit operator EncLong(uint value) => new EncLong(value); + public static implicit operator EncLong(ushort value) => new EncLong(value); + public static implicit operator EncLong(short value) => new EncLong(value); + public static implicit operator EncLong(byte value) => new EncLong(value); + public static implicit operator EncLong(sbyte value) => new EncLong(value); + public static explicit operator EncLong(decimal value) => new EncLong((long)value); + public static explicit operator EncLong(double value) => new EncLong((long)value); + public static explicit operator EncLong(float value) => new EncLong((long)value); + public static explicit operator ulong(EncLong elong1) => (ulong)elong1.Value; - public static implicit operator long(EncLong elong1) => (long)elong1.Value; + public static implicit operator long(EncLong elong1) => elong1.Value; public static explicit operator uint(EncLong elong1) => (uint)elong1.Value; public static explicit operator int(EncLong elong1) => (int)elong1.Value; public static explicit operator ushort(EncLong elong1) => (ushort)elong1.Value; public static explicit operator short(EncLong elong1) => (short)elong1.Value; public static explicit operator byte(EncLong elong1) => (byte)elong1.Value; public static explicit operator sbyte(EncLong elong1) => (sbyte)elong1.Value; - public static explicit operator decimal(EncLong elong1) => elong1.Value; - public static explicit operator double(EncLong elong1) => (double)elong1.Value; - public static explicit operator float(EncLong elong1) => (float)elong1.Value; + public static implicit operator decimal(EncLong elong1) => elong1.Value; + public static implicit operator double(EncLong elong1) => elong1.Value; + public static implicit operator float(EncLong elong1) => elong1.Value; #endregion } \ No newline at end of file diff --git a/EncTypes/EncString.cs b/EncTypes/EncString.cs index 6c4ee51..ca6c0a5 100644 --- a/EncTypes/EncString.cs +++ b/EncTypes/EncString.cs @@ -4,23 +4,25 @@ public class EncString { - /// A class for storing a string while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a wierd string that is affected by a very long random key. { encryptionKey } - /// Every time the value of the string changes, the encryption key changes too. And it works exactly as an string. + /// A class for storing a string while efficiently keeping it encrypted in the memory + /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted + /// The encryption will happen in the background without you worrying about it + /// In the memory it is saved as a wierd char array that is affected by random keys { encryptionKeys } + /// Every time the value of the string changes, the encryption keys change too. And it works exactly as a string /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties - private readonly string _encryptionKey; - private readonly string _encryptedValue; + private readonly char[] _encryptionKeys; + private readonly char[] _encryptedValue; /// /// The decrypted value of the stored string. /// private string Value { - get => EncryptorDecryptor(_encryptedValue, _encryptionKey); + get => Decrypt(); } public int Length @@ -41,8 +43,7 @@ public char this[int index] #endregion #region Methods - - public bool IsEqual(EncString encString) => encString.Value == this.Value; + public bool IsObjectEqual(EncString encString) => encString == this; public bool IsNull() => this.Value == null; public object Clone() => Value.Clone(); public override bool Equals(object obj) => Value.Equals(obj); @@ -125,8 +126,8 @@ public char this[int index] public EncString(string value) { - _encryptionKey = RandomString(); - _encryptedValue = EncryptorDecryptor(value, _encryptionKey); + _encryptionKeys = EncKeys(); + _encryptedValue = Encrypt(value, _encryptionKeys); } public EncString(char[] value) @@ -145,24 +146,17 @@ public EncString(char[] value, int startIndex, int length) static Random random = new Random(); - static int RandomLength() => random.Next(10, 150); - - static char RandomChar(int min = char.MinValue, int max = (char.MaxValue - 1)) - { - return (char)(random.Next(min, max)); - } - - static string RandomString() + static char[] EncKeys() { - char[] chars = new char[RandomLength()]; + char[] chars = new char[random.Next(10, 100)]; // random length for (int i = 0; i < chars.Length; i++) { - chars[i] = RandomChar(); + chars[i] = (char)(random.Next(char.MinValue, char.MinValue)); // random chars } - return new string(chars); + return chars; } - private static string EncryptorDecryptor(string data, string key) + private static char[] Encrypt(string data, char[] key) { if (data == null) { @@ -179,6 +173,27 @@ private static string EncryptorDecryptor(string data, string key) output[i] = (char)(data[i] ^ key[i % keyLen]); } + return output; + } + } + + private string Decrypt() + { + if (_encryptedValue == null) + { + return null; + } + else + { + int dataLen = _encryptedValue.Length; + int keyLen = _encryptionKeys.Length; + char[] output = new char[dataLen]; + + for (int i = 0; i < dataLen; ++i) + { + output[i] = (char)(_encryptedValue[i] ^ _encryptionKeys[i % keyLen]); + } + return new string(output); } } @@ -194,9 +209,12 @@ private static string EncryptorDecryptor(string data, string key) /// == != < > public static bool operator ==(EncString es1, string es2) => es1.Value == es2; public static bool operator !=(EncString es1, string es2) => es1.Value != es2; + public static bool operator ==(EncString es1, EncString es2) => es1.Value == es2.Value; + public static bool operator !=(EncString es1, EncString es2) => es1.Value != es2.Value; /// assign public static implicit operator EncString(string value) => new EncString(value); + public static explicit operator EncString(char[] value) => new EncString(value); public static implicit operator string(EncString encString) => encString.Value; #endregion From fb8e2bfdd659579a80c508cad70e1d2586d09102 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 14:36:24 +0200 Subject: [PATCH 41/53] Fixed the bug that caused the application to crash --- .../Benchmark/BenchmarkPresetGroup.cs | 1 + .../Benchmark/BenchmarksManager.cs | 22 +++++++++---------- .../Benchmark/VarEncBenchmark.cs | 6 ++--- 3 files changed, 14 insertions(+), 15 deletions(-) diff --git a/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkPresetGroup.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkPresetGroup.cs index 1746acc..3457ff6 100644 --- a/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkPresetGroup.cs +++ b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkPresetGroup.cs @@ -12,6 +12,7 @@ public string Name } public BenchmarkPreset[] presets; + public BenchmarkPresetGroup(string name, BenchmarkPreset[] benchmarkPresets) { _name = name; diff --git a/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs index 3e2116f..57c2d9e 100644 --- a/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs +++ b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs @@ -164,17 +164,6 @@ static string[] ResultsAnalysis #region Benchmark Presets - static public BenchmarkPresetGroup[] benchmarkPresetGroups = - { - new BenchmarkPresetGroup("Fastest", benchmarkPresetsFastest), - new BenchmarkPresetGroup("Very Fast", benchmarkPresetsVeryFast), - new BenchmarkPresetGroup("Fast", benchmarkPresetsFast), - new BenchmarkPresetGroup("Normal", benchmarkPresetsNormal), - new BenchmarkPresetGroup("Medium", benchmarkPresetsMedium), - new BenchmarkPresetGroup("Long", benchmarkPresetsLong), - new BenchmarkPresetGroup("Very Long", benchmarkPresetsVeryLong), - }; - static BenchmarkPreset[] benchmarkPresetsFastest = { new BenchmarkPreset(20, 50000), @@ -231,6 +220,17 @@ static string[] ResultsAnalysis new BenchmarkPreset(10, 50000000), }; + static public BenchmarkPresetGroup[] benchmarkPresetGroups = + { + new BenchmarkPresetGroup("Fastest", benchmarkPresetsFastest), + new BenchmarkPresetGroup("Very Fast", benchmarkPresetsVeryFast), + new BenchmarkPresetGroup("Fast", benchmarkPresetsFast), + new BenchmarkPresetGroup("Normal", benchmarkPresetsNormal), + new BenchmarkPresetGroup("Medium", benchmarkPresetsMedium), + new BenchmarkPresetGroup("Long", benchmarkPresetsLong), + new BenchmarkPresetGroup("Very Long", benchmarkPresetsVeryLong), + }; + #endregion #region Methods diff --git a/Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs index 8ec7ac8..1e91a79 100644 --- a/Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs +++ b/Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs @@ -178,9 +178,9 @@ public static void PrintBenchmarkPresetGroupList() } // Section #3 - public static void PrintBenchmarkPresetGroup(BenchmarkPresetGroup _group) + public static void PrintBenchmarkPresetGroup() { - BenchmarkPresetGroup group = _group; + BenchmarkPresetGroup group = currentBenchmarkPresetGroup; WriteLine(string.Format("These are the {0} benchmark presets:", group.Name)); for (int i = 0; i < group.presets.Length; i++) { @@ -201,8 +201,6 @@ public static void PrintBenchmarkPresetGroup(BenchmarkPresetGroup _group) } } - public static void PrintBenchmarkPresetGroup() => PrintBenchmarkPresetGroup(currentBenchmarkPresetGroup); - // Special Section - input "s" in the menu public static void PrintSizesOfTypes() From 89bfa39fd80fe2fa5cd8ae983f5fbde001625dfe Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 14:55:00 +0200 Subject: [PATCH 42/53] Updated encryption keys in EncInt/Float --- Benchmark/Solution/Variable-Encryption/Types/EncFloat.cs | 5 +++-- Benchmark/Solution/Variable-Encryption/Types/EncInt.cs | 4 ++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/Benchmark/Solution/Variable-Encryption/Types/EncFloat.cs b/Benchmark/Solution/Variable-Encryption/Types/EncFloat.cs index 23778c7..3c8c05a 100644 --- a/Benchmark/Solution/Variable-Encryption/Types/EncFloat.cs +++ b/Benchmark/Solution/Variable-Encryption/Types/EncFloat.cs @@ -35,10 +35,11 @@ private float Value #endregion #region Methods And Constructors + private EncFloat(float value) { - encryptionKey1 = random.NextDouble() * 0.001; - encryptionKey2 = random.NextDouble() * 100; + encryptionKey1 = random.NextDouble() * 0.01; + encryptionKey2 = random.NextDouble() * 10; encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); } diff --git a/Benchmark/Solution/Variable-Encryption/Types/EncInt.cs b/Benchmark/Solution/Variable-Encryption/Types/EncInt.cs index 4aa5dc8..05b6a2d 100644 --- a/Benchmark/Solution/Variable-Encryption/Types/EncInt.cs +++ b/Benchmark/Solution/Variable-Encryption/Types/EncInt.cs @@ -34,8 +34,8 @@ private int Value private EncInt(int value) { - encryptionKey1 = random.NextDouble() * 0.001; - encryptionKey2 = random.NextDouble() * 100; + encryptionKey1 = random.NextDouble() * 0.01; + encryptionKey2 = random.NextDouble() * 10; encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); } From 33017bf5b99f8b7e63242351f14131cacc50f006 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 15:00:22 +0200 Subject: [PATCH 43/53] Update VariableEncryption.dll --- Benchmark/VariableEncryption.dll | Bin 151552 -> 151040 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/Benchmark/VariableEncryption.dll b/Benchmark/VariableEncryption.dll index 0f3652d94f29821759f9edd236d671fe4c279287..961c87bfaec7af742cff6552afc7b5eec3aa7944 100644 GIT binary patch literal 151040 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

JaQCa)_U9#S zN}EggT3ugP%@$Gyx}QT|etE7>6!Ce0I~aqvtME@Xi*BdVFXP8=ePO#hBFBw8kKTCd z6IwUqRs;Ql|L2i+39%&x?GzEcm)YGYKsnKE0=!j#<9`zEi5zcRxZ~A#WM7_8fG4AGRKvZw{mZk(y=tqm zji>V5rXu4(Sg|-1wp2&x#UprQI&ssOE%H}%ZqBY8U|Vv(q%eozI(tzi^tyfi$jNs5 zBkJ?&tn|a!c!Io--_<#=d6abVcp&r)>ipFzJdTbhRX?KCD^6+=e~}zS;hO9j%fWuo zEH+7R&Q?SHHKp!svEL}y@Kh*Z+~%*TSffP9#Z$C#s$U$_y>xL10vePqx*5VP`oHi$ W1S|Z+o%z9)U%2G|7x;ewf&T$(^&&d} literal 151552 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®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 WKlL93D}05aaTs=g{_``3!2bbQ3UAl| From 6e78f10242286bd98c53fc517d54fe0af7f68235 Mon Sep 17 00:00:00 2001 From: Josepe <72740829+JosepeDev@users.noreply.github.com> Date: Sat, 19 Dec 2020 15:03:40 +0200 Subject: [PATCH 44/53] Update README.md --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 9213e33..0343137 100644 --- a/README.md +++ b/README.md @@ -116,7 +116,8 @@ After the benchmark is finished, the results will be printed. From there you can I ran a few benchmarks on my Laptop (Intel Core i7-8750h, GTX1060-MaxQ), and these are the results: | Comparison | CPS (Changes per second) | |---------------------------------------------------------|:------------------------:| -| **EncInt** - int (Similar to **EncLong**) | 16,019,622 - 525,762,355 | +| **EncInt** - int | 16,508,079 - 600,146,109 | +| **EncLong** - long | 3,835,249 - 430,079,779 | | **EncDouble** - double (Similar to **EncFloat** and **EncDecimal**) | 20,155,276 - 329,739,613 | | **EncString** - string | 501,253 - 13,579,435 | From a95f2595938f67b497bdf3f75b46835b155cb315 Mon Sep 17 00:00:00 2001 From: Josepe <72740829+JosepeDev@users.noreply.github.com> Date: Sat, 19 Dec 2020 15:51:59 +0200 Subject: [PATCH 45/53] Update README.md --- README.md | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 0343137..2161376 100644 --- a/README.md +++ b/README.md @@ -114,12 +114,14 @@ After the benchmark is finished, the results will be printed. From there you can ### Performance I ran a few benchmarks on my Laptop (Intel Core i7-8750h, GTX1060-MaxQ), and these are the results: -| Comparison | CPS (Changes per second) | -|---------------------------------------------------------|:------------------------:| -| **EncInt** - int | 16,508,079 - 600,146,109 | -| **EncLong** - long | 3,835,249 - 430,079,779 | -| **EncDouble** - double (Similar to **EncFloat** and **EncDecimal**) | 20,155,276 - 329,739,613 | -| **EncString** - string | 501,253 - 13,579,435 | +| Variable Type | CPS (Changes per second) | +|---------------|--------------------------| +| EncInt | 5,837,044 | +| EncLong | 3,980,810 | +| EncFloat | 5,625,961 | +| EncDouble | 3,928,240 | +| EncDecimal | 4,213,448 | +| EncString | 584,270 | This is the size of each EncType compared to its normal type | Types | Size in bytes | From 9a51c1ff063dc3e83ddaf09661009feeaad9e303 Mon Sep 17 00:00:00 2001 From: Josepe <72740829+JosepeDev@users.noreply.github.com> Date: Sat, 19 Dec 2020 15:52:51 +0200 Subject: [PATCH 46/53] Update README.md --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 2161376..7e00b75 100644 --- a/README.md +++ b/README.md @@ -126,11 +126,11 @@ I ran a few benchmarks on my Laptop (Intel Core i7-8750h, GTX1060-MaxQ), and the This is the size of each EncType compared to its normal type | Types | Size in bytes | |:--------------------:|:-------------:| -| int - EncInt | 4 - 24 | -| long - EncLong | 8 - 48 | -| float - EncFloat | 4 - 24 | -| double - EncDouble | 8 - 48 | -| decimal - EncDecimal | 16 - 48 | +| int - EncInt | 4 - 8 | +| long - EncLong | 8 - 16 | +| float - EncFloat | 4 - 8 | +| double - EncDouble | 8 - 16 | +| decimal - EncDecimal | 16 - 32 | It may seem heavy but it's **very light** considering its **simple** and **efficient encryption**. In a game where you want to have an encrypted "**score**" for the player, you can just **switch** the score's variable **type** from an **int** to an **EncInt**. From 119df009a296d5d3551760c962cae935a332103e Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 16:21:35 +0200 Subject: [PATCH 47/53] EncTypes update - Now every EncType uses a bitwise encryption. - Updated description --- .../Variable-Encryption/Types/EncDecimal.cs | 331 +++++++++--------- .../Variable-Encryption/Types/EncDouble.cs | 316 +++++++++-------- .../Variable-Encryption/Types/EncFloat.cs | 323 ++++++++--------- .../Variable-Encryption/Types/EncInt.cs | 287 +++++++-------- .../Variable-Encryption/Types/EncLong.cs | 253 +++++++------ 5 files changed, 761 insertions(+), 749 deletions(-) diff --git a/Benchmark/Solution/Variable-Encryption/Types/EncDecimal.cs b/Benchmark/Solution/Variable-Encryption/Types/EncDecimal.cs index 0aec94f..b77f726 100644 --- a/Benchmark/Solution/Variable-Encryption/Types/EncDecimal.cs +++ b/Benchmark/Solution/Variable-Encryption/Types/EncDecimal.cs @@ -2,11 +2,11 @@ public struct EncDecimal { - /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory. + /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted /// The encryption will happen in the background without you worrying about it /// In the memory it is saved as a an array of weird bytes that are affected by random values { encryptionKeys array } - /// Every time the value changes, the encryption keys change too. And it works exactly as a deciaml. + /// Every time the value changes, the encryption keys change too. And it works exactly as a deciaml /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc @@ -17,10 +17,18 @@ public struct EncDecimal // The encrypted value stored in memory private readonly int[] encryptedValue; - // The decrypted value - private decimal Value + // Takes an encrypted value and returns it decrypted + private decimal Decrypt { - get => Decrypt(); + get + { + var decrypted = new int[4]; + for (int i = 0; i < 4; i++) + { + decrypted[i] = encryptedValue[i] ^ encryptionKeys[i]; + } + return new decimal(decrypted); + } } public static Decimal MaxValue { get => Decimal.MaxValue; } @@ -63,28 +71,17 @@ private static int[] Encrypt(decimal value, int[] keys) return valueInBits; } - // Takes an encrypted value and returns it decrypted - private decimal Decrypt() - { - var decrypted = new int[4]; - for (int i = 0; i < 4; i++) - { - decrypted[i] = encryptedValue[i] ^ encryptionKeys[i]; - } - return new decimal(decrypted); - } - // Overrides - public int CompareTo(Decimal value) => Value.CompareTo(value); - public int CompareTo(object value) => Value.CompareTo(value); - public bool Equals(Decimal value) => Value.Equals(value); - public override bool Equals(object value) => Value.Equals(value); - public override int GetHashCode() => Value.GetHashCode(); - public TypeCode GetTypeCode() => Value.GetTypeCode(); - public string ToString(string format) => Value.ToString(format); - public string ToString(IFormatProvider provider) => Value.ToString(provider); - public override string ToString() => Value.ToString(); - public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + public int CompareTo(Decimal value) => Decrypt.CompareTo(value); + public int CompareTo(object value) => Decrypt.CompareTo(value); + public bool Equals(Decimal value) => Decrypt.Equals(value); + public override bool Equals(object value) => Decrypt.Equals(value); + public override int GetHashCode() => Decrypt.GetHashCode(); + public TypeCode GetTypeCode() => Decrypt.GetTypeCode(); + public string ToString(string format) => Decrypt.ToString(format); + public string ToString(IFormatProvider provider) => Decrypt.ToString(provider); + public override string ToString() => Decrypt.ToString(); + public string ToString(string format, IFormatProvider provider) => Decrypt.ToString(format, provider); #endregion @@ -92,139 +89,139 @@ private decimal Decrypt() /// + - * / % - public static EncDecimal operator +(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Value + eint2.Value); - public static EncDecimal operator -(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Value - eint2.Value); - public static EncDecimal operator *(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Value * eint2.Value); - public static EncDecimal operator /(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Value / eint2.Value); - public static EncDecimal operator %(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Value % eint2.Value); - - public static decimal operator +(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, long edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, long edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, long edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, long edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, long edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, int edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, int edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, int edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, int edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, int edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, short edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, short edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, short edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, short edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, short edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, double edecimal2) => edecimal1.Value + (decimal)edecimal2; - public static decimal operator -(EncDecimal edecimal1, double edecimal2) => edecimal1.Value - (decimal)edecimal2; - public static decimal operator *(EncDecimal edecimal1, double edecimal2) => edecimal1.Value * (decimal)edecimal2; - public static decimal operator /(EncDecimal edecimal1, double edecimal2) => edecimal1.Value / (decimal)edecimal2; - public static decimal operator %(EncDecimal edecimal1, double edecimal2) => edecimal1.Value % (decimal)edecimal2; - - public static decimal operator +(EncDecimal edecimal1, float edecimal2) => edecimal1.Value + (decimal)edecimal2; - public static decimal operator -(EncDecimal edecimal1, float edecimal2) => edecimal1.Value - (decimal)edecimal2; - public static decimal operator *(EncDecimal edecimal1, float edecimal2) => edecimal1.Value * (decimal)edecimal2; - public static decimal operator /(EncDecimal edecimal1, float edecimal2) => edecimal1.Value / (decimal)edecimal2; - public static decimal operator %(EncDecimal edecimal1, float edecimal2) => edecimal1.Value % (decimal)edecimal2; + public static EncDecimal operator +(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Decrypt + eint2.Decrypt); + public static EncDecimal operator -(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Decrypt - eint2.Decrypt); + public static EncDecimal operator *(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Decrypt * eint2.Decrypt); + public static EncDecimal operator /(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Decrypt / eint2.Decrypt); + public static EncDecimal operator %(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Decrypt % eint2.Decrypt); + + public static decimal operator +(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, long edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, long edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, long edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, long edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, long edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, uint edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, uint edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, uint edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, uint edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, uint edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, int edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, int edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, int edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, int edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, int edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, short edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, short edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, short edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, short edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, short edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, byte edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, byte edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, byte edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, byte edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, byte edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, double edecimal2) => edecimal1.Decrypt + (decimal)edecimal2; + public static decimal operator -(EncDecimal edecimal1, double edecimal2) => edecimal1.Decrypt - (decimal)edecimal2; + public static decimal operator *(EncDecimal edecimal1, double edecimal2) => edecimal1.Decrypt * (decimal)edecimal2; + public static decimal operator /(EncDecimal edecimal1, double edecimal2) => edecimal1.Decrypt / (decimal)edecimal2; + public static decimal operator %(EncDecimal edecimal1, double edecimal2) => edecimal1.Decrypt % (decimal)edecimal2; + + public static decimal operator +(EncDecimal edecimal1, float edecimal2) => edecimal1.Decrypt + (decimal)edecimal2; + public static decimal operator -(EncDecimal edecimal1, float edecimal2) => edecimal1.Decrypt - (decimal)edecimal2; + public static decimal operator *(EncDecimal edecimal1, float edecimal2) => edecimal1.Decrypt * (decimal)edecimal2; + public static decimal operator /(EncDecimal edecimal1, float edecimal2) => edecimal1.Decrypt / (decimal)edecimal2; + public static decimal operator %(EncDecimal edecimal1, float edecimal2) => edecimal1.Decrypt % (decimal)edecimal2; /// == != < > - public static bool operator ==(EncDecimal eint1, EncDecimal eint2) => eint1.Value == eint2.Value; - public static bool operator !=(EncDecimal eint1, EncDecimal eint2) => eint1.Value != eint2.Value; - public static bool operator <(EncDecimal eint1, EncDecimal eint2) => eint1.Value < eint2.Value; - public static bool operator >(EncDecimal eint1, EncDecimal eint2) => eint1.Value > eint2.Value; - - public static bool operator ==(EncDecimal eint1, ulong eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, ulong eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, ulong eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, ulong eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, long eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, long eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, long eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, long eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, uint eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, uint eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, uint eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, uint eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, int eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, int eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, int eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, int eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, ushort eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, ushort eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, ushort eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, ushort eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, short eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, short eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, short eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, short eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, byte eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, byte eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, byte eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, byte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, sbyte eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, sbyte eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, sbyte eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, sbyte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, decimal eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, decimal eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, decimal eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, decimal eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, double eint2) => eint1.Value == (decimal)eint2; - public static bool operator !=(EncDecimal eint1, double eint2) => eint1.Value != (decimal)eint2; - public static bool operator >(EncDecimal eint1, double eint2) => eint1.Value > (decimal)eint2; - public static bool operator <(EncDecimal eint1, double eint2) => eint1.Value < (decimal)eint2; - - public static bool operator ==(EncDecimal eint1, float eint2) => eint1.Value == (decimal)eint2; - public static bool operator !=(EncDecimal eint1, float eint2) => eint1.Value != (decimal)eint2; - public static bool operator >(EncDecimal eint1, float eint2) => eint1.Value > (decimal)eint2; - public static bool operator <(EncDecimal eint1, float eint2) => eint1.Value < (decimal)eint2; + public static bool operator ==(EncDecimal eint1, EncDecimal eint2) => eint1.Decrypt == eint2.Decrypt; + public static bool operator !=(EncDecimal eint1, EncDecimal eint2) => eint1.Decrypt != eint2.Decrypt; + public static bool operator <(EncDecimal eint1, EncDecimal eint2) => eint1.Decrypt < eint2.Decrypt; + public static bool operator >(EncDecimal eint1, EncDecimal eint2) => eint1.Decrypt > eint2.Decrypt; + + public static bool operator ==(EncDecimal eint1, ulong eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, ulong eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, ulong eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, ulong eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, long eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, long eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, long eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, long eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, uint eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, uint eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, uint eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, uint eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, int eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, int eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, int eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, int eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, ushort eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, ushort eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, ushort eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, ushort eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, short eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, short eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, short eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, short eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, byte eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, byte eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, byte eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, byte eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, sbyte eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, sbyte eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, sbyte eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, sbyte eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, decimal eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, decimal eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, decimal eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, decimal eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, double eint2) => eint1.Decrypt == (decimal)eint2; + public static bool operator !=(EncDecimal eint1, double eint2) => eint1.Decrypt != (decimal)eint2; + public static bool operator >(EncDecimal eint1, double eint2) => eint1.Decrypt > (decimal)eint2; + public static bool operator <(EncDecimal eint1, double eint2) => eint1.Decrypt < (decimal)eint2; + + public static bool operator ==(EncDecimal eint1, float eint2) => eint1.Decrypt == (decimal)eint2; + public static bool operator !=(EncDecimal eint1, float eint2) => eint1.Decrypt != (decimal)eint2; + public static bool operator >(EncDecimal eint1, float eint2) => eint1.Decrypt > (decimal)eint2; + public static bool operator <(EncDecimal eint1, float eint2) => eint1.Decrypt < (decimal)eint2; /// assign @@ -240,17 +237,17 @@ private decimal Decrypt() public static implicit operator EncDecimal(byte value) => new EncDecimal(value); public static implicit operator EncDecimal(sbyte value) => new EncDecimal(value); - public static implicit operator decimal(EncDecimal eint1) => eint1.Value; - public static explicit operator double(EncDecimal eint1) => (double)eint1.Value; - public static explicit operator float(EncDecimal eint1) => (float)eint1.Value; - public static explicit operator ulong(EncDecimal eint1) => (ulong)eint1.Value; - public static explicit operator long(EncDecimal eint1) => (long)eint1.Value; - public static explicit operator uint(EncDecimal eint1) => (uint)eint1.Value; - public static explicit operator int(EncDecimal eint1) => (int)eint1.Value; - public static explicit operator ushort(EncDecimal eint1) => (ushort)eint1.Value; - public static explicit operator short(EncDecimal eint1) => (short)eint1.Value; - public static explicit operator byte(EncDecimal eint1) => (byte)eint1.Value; - public static explicit operator sbyte(EncDecimal eint1) => (sbyte)eint1.Value; + public static implicit operator decimal(EncDecimal eint1) => eint1.Decrypt; + public static explicit operator double(EncDecimal eint1) => (double)eint1.Decrypt; + public static explicit operator float(EncDecimal eint1) => (float)eint1.Decrypt; + public static explicit operator ulong(EncDecimal eint1) => (ulong)eint1.Decrypt; + public static explicit operator long(EncDecimal eint1) => (long)eint1.Decrypt; + public static explicit operator uint(EncDecimal eint1) => (uint)eint1.Decrypt; + public static explicit operator int(EncDecimal eint1) => (int)eint1.Decrypt; + public static explicit operator ushort(EncDecimal eint1) => (ushort)eint1.Decrypt; + public static explicit operator short(EncDecimal eint1) => (short)eint1.Decrypt; + public static explicit operator byte(EncDecimal eint1) => (byte)eint1.Decrypt; + public static explicit operator sbyte(EncDecimal eint1) => (sbyte)eint1.Decrypt; #endregion } \ No newline at end of file diff --git a/Benchmark/Solution/Variable-Encryption/Types/EncDouble.cs b/Benchmark/Solution/Variable-Encryption/Types/EncDouble.cs index 0561a02..d7e12d7 100644 --- a/Benchmark/Solution/Variable-Encryption/Types/EncDouble.cs +++ b/Benchmark/Solution/Variable-Encryption/Types/EncDouble.cs @@ -12,16 +12,23 @@ public struct EncDouble #region Variables And Properties - // The encryption values private readonly byte[] encryptionKeys; // The encrypted value stored in memory private readonly byte[] encryptedValue; - // The decrypted value - public double Value + // Takes an encrypted value and returns it decrypted + private double Decrypt { - get => Decrypt(); + get + { + var valueBytes = new byte[8]; + for (int i = 0; i < 8; i++) + { + valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); + } + return BitConverter.ToDouble(valueBytes); + } } public static Double Epsilon { get => Double.Epsilon; } @@ -56,161 +63,150 @@ private static byte[] Encrypt(double value, byte[] keys) return valueBytes; } - // Takes an encrypted value and returns it decrypted - private double Decrypt() - { - var valueBytes = new byte[8]; - for (int i = 0; i < 8; i++) - { - valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); - } - return BitConverter.ToDouble(valueBytes); - } - // Overrides - public int CompareTo(object value) => Value.CompareTo(value); - public int CompareTo(Double value) => Value.CompareTo(value); - public bool Equals(Double obj) => Value.Equals(obj); - public override bool Equals(object obj) => Value.Equals(obj); - public override int GetHashCode() => Value.GetHashCode(); - public TypeCode GetTypeCode() => Value.GetTypeCode(); - public override string ToString() => Value.ToString(); - public string ToString(IFormatProvider provider) => Value.ToString(provider); - public string ToString(string format) => Value.ToString(format); - public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + public int CompareTo(object value) => Decrypt.CompareTo(value); + public int CompareTo(Double value) => Decrypt.CompareTo(value); + public bool Equals(Double obj) => Decrypt.Equals(obj); + public override bool Equals(object obj) => Decrypt.Equals(obj); + public override int GetHashCode() => Decrypt.GetHashCode(); + public TypeCode GetTypeCode() => Decrypt.GetTypeCode(); + public override string ToString() => Decrypt.ToString(); + public string ToString(IFormatProvider provider) => Decrypt.ToString(provider); + public string ToString(string format) => Decrypt.ToString(format); + public string ToString(string format, IFormatProvider provider) => Decrypt.ToString(format, provider); #endregion #region Operators Overloading /// + - * / % - public static EncDouble operator +(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Value + eint2.Value); - public static EncDouble operator -(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Value - eint2.Value); - public static EncDouble operator *(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Value * eint2.Value); - public static EncDouble operator /(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Value / eint2.Value); - public static EncDouble operator %(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Value % eint2.Value); - - public static double operator +(EncDouble edouble1, ulong edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, ulong edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, ulong edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, ulong edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, ulong edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, long edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, long edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, long edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, long edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, long edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, uint edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, uint edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, uint edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, uint edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, uint edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, int edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, int edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, int edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, int edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, int edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, ushort edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, ushort edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, ushort edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, ushort edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, ushort edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, short edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, short edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, short edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, short edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, short edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, byte edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, byte edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, byte edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, byte edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, byte edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, sbyte edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, sbyte edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, sbyte edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, sbyte edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, sbyte edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, double edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, double edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, double edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, double edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, double edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, float edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, float edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, float edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, float edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, float edouble2) => edouble1.Value % edouble2; + public static EncDouble operator +(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Decrypt + eint2.Decrypt); + public static EncDouble operator -(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Decrypt - eint2.Decrypt); + public static EncDouble operator *(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Decrypt * eint2.Decrypt); + public static EncDouble operator /(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Decrypt / eint2.Decrypt); + public static EncDouble operator %(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Decrypt % eint2.Decrypt); + + public static double operator +(EncDouble edouble1, ulong edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, ulong edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, ulong edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, ulong edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, ulong edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, long edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, long edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, long edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, long edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, long edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, uint edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, uint edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, uint edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, uint edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, uint edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, int edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, int edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, int edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, int edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, int edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, ushort edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, ushort edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, ushort edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, ushort edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, ushort edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, short edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, short edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, short edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, short edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, short edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, byte edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, byte edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, byte edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, byte edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, byte edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, sbyte edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, sbyte edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, sbyte edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, sbyte edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, sbyte edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, double edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, double edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, double edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, double edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, double edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, float edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, float edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, float edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, float edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, float edouble2) => edouble1.Decrypt % edouble2; /// == != < > - public static bool operator ==(EncDouble eint1, EncDouble eint2) => eint1.Value == eint2.Value; - public static bool operator !=(EncDouble eint1, EncDouble eint2) => eint1.Value != eint2.Value; - public static bool operator <(EncDouble eint1, EncDouble eint2) => eint1.Value < eint2.Value; - public static bool operator >(EncDouble eint1, EncDouble eint2) => eint1.Value > eint2.Value; - - public static bool operator ==(EncDouble eint1, ulong eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, ulong eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, ulong eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, ulong eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, long eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, long eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, long eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, long eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, uint eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, uint eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, uint eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, uint eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, int eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, int eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, int eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, int eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, ushort eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, ushort eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, ushort eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, ushort eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, short eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, short eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, short eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, short eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, byte eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, byte eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, byte eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, byte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, sbyte eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, sbyte eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, sbyte eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, sbyte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, decimal eint2) => (decimal)eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, decimal eint2) => (decimal)eint1.Value != eint2; - public static bool operator >(EncDouble eint1, decimal eint2) => (decimal)eint1.Value > eint2; - public static bool operator <(EncDouble eint1, decimal eint2) => (decimal)eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, double eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, double eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, double eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, double eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, float eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, float eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, float eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, float eint2) => eint1.Value < eint2; + public static bool operator ==(EncDouble eint1, EncDouble eint2) => eint1.Decrypt == eint2.Decrypt; + public static bool operator !=(EncDouble eint1, EncDouble eint2) => eint1.Decrypt != eint2.Decrypt; + public static bool operator <(EncDouble eint1, EncDouble eint2) => eint1.Decrypt < eint2.Decrypt; + public static bool operator >(EncDouble eint1, EncDouble eint2) => eint1.Decrypt > eint2.Decrypt; + + public static bool operator ==(EncDouble eint1, ulong eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, ulong eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, ulong eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, ulong eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, long eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, long eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, long eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, long eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, uint eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, uint eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, uint eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, uint eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, int eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, int eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, int eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, int eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, ushort eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, ushort eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, ushort eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, ushort eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, short eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, short eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, short eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, short eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, byte eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, byte eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, byte eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, byte eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, sbyte eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, sbyte eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, sbyte eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, sbyte eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, decimal eint2) => (decimal)eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, decimal eint2) => (decimal)eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, decimal eint2) => (decimal)eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, decimal eint2) => (decimal)eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, double eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, double eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, double eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, double eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, float eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, float eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, float eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, float eint2) => eint1.Decrypt < eint2; /// assign public static implicit operator EncDouble(ulong value) => new EncDouble(value); @@ -225,17 +221,17 @@ private double Decrypt() public static implicit operator EncDouble(double value) => new EncDouble(value); public static implicit operator EncDouble(float value) => new EncDouble(value); - public static explicit operator decimal(EncDouble eint1) => (decimal)eint1.Value; - public static implicit operator double(EncDouble eint1) => eint1.Value; - public static explicit operator float(EncDouble eint1) => (float)eint1.Value; - public static explicit operator ulong(EncDouble eint1) => (ulong)eint1.Value; - public static explicit operator long(EncDouble eint1) => (long)eint1.Value; - public static explicit operator uint(EncDouble eint1) => (uint)eint1.Value; - public static explicit operator int(EncDouble eint1) => (int)eint1.Value; - public static explicit operator ushort(EncDouble eint1) => (ushort)eint1.Value; - public static explicit operator short(EncDouble eint1) => (short)eint1.Value; - public static explicit operator byte(EncDouble eint1) => (byte)eint1.Value; - public static explicit operator sbyte(EncDouble eint1) => (sbyte)eint1.Value; + public static explicit operator decimal(EncDouble eint1) => (decimal)eint1.Decrypt; + public static implicit operator double(EncDouble eint1) => eint1.Decrypt; + public static explicit operator float(EncDouble eint1) => (float)eint1.Decrypt; + public static explicit operator ulong(EncDouble eint1) => (ulong)eint1.Decrypt; + public static explicit operator long(EncDouble eint1) => (long)eint1.Decrypt; + public static explicit operator uint(EncDouble eint1) => (uint)eint1.Decrypt; + public static explicit operator int(EncDouble eint1) => (int)eint1.Decrypt; + public static explicit operator ushort(EncDouble eint1) => (ushort)eint1.Decrypt; + public static explicit operator short(EncDouble eint1) => (short)eint1.Decrypt; + public static explicit operator byte(EncDouble eint1) => (byte)eint1.Decrypt; + public static explicit operator sbyte(EncDouble eint1) => (sbyte)eint1.Decrypt; #endregion } \ No newline at end of file diff --git a/Benchmark/Solution/Variable-Encryption/Types/EncFloat.cs b/Benchmark/Solution/Variable-Encryption/Types/EncFloat.cs index 3c8c05a..b126d85 100644 --- a/Benchmark/Solution/Variable-Encryption/Types/EncFloat.cs +++ b/Benchmark/Solution/Variable-Encryption/Types/EncFloat.cs @@ -2,27 +2,33 @@ public struct EncFloat { - /// A struct for storing a Single (float) while efficiently keeping it encrypted in the memory. + /// A struct for storing a Single (float) while efficiently keeping it encrypted in the memory /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted /// The encryption will happen in the background without you worrying about it - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an float. + /// In the memory it is saved as a an array of weird bytes that are affected by random values { encryptionKeys array } + /// Every time the value changes, the encryption keys change too. And it works exactly as an float (Single) /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties - // The encryption values - private readonly double encryptionKey1; - private readonly double encryptionKey2; + private readonly byte[] encryptionKeys; // The encrypted value stored in memory - private readonly double encryptedValue; + private readonly byte[] encryptedValue; - // The decrypted value - private float Value + // Takes an encrypted value and returns it decrypted + private float Decrypt { - get => (float)Decrypt(); + get + { + var valueBytes = new byte[4]; + for (int i = 0; i < 4; i++) + { + valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); + } + return BitConverter.ToSingle(valueBytes); + } } public static float Epsilon { get => Single.Epsilon; } @@ -38,158 +44,163 @@ private float Value private EncFloat(float value) { - encryptionKey1 = random.NextDouble() * 0.01; - encryptionKey2 = random.NextDouble() * 10; - encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + encryptionKeys = new byte[4]; + encryptedValue = Encrypt(value, encryptionKeys); } // encryption key generator static private Random random = new Random(); // Takes a given value and returns it encrypted - private static double Encrypt(double value, double k1, double k2) => (value * k1) * k2; - - // Takes an encrypted value and returns it decrypted - private double Decrypt() => (encryptedValue / encryptionKey2) / encryptionKey1; + private static byte[] Encrypt(float value, byte[] keys) + { + random.NextBytes(keys); + var valueBytes = BitConverter.GetBytes(value); + for (int i = 0; i < 4; i++) + { + valueBytes[i] ^= keys[i]; + } + return valueBytes; + } // Single methods - public int CompareTo(Single value) => Value.CompareTo(value); - public int CompareTo(object value) => Value.CompareTo(value); - public override bool Equals(object obj) => Value.Equals(obj); - public bool Equals(Single obj) => Value.Equals(obj); - public override int GetHashCode() => Value.GetHashCode(); - public TypeCode GetTypeCode() => Value.GetTypeCode(); - public override string ToString() => Value.ToString(); - public string ToString(IFormatProvider provider) => Value.ToString(provider); - public string ToString(string format) => Value.ToString(format); - public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + public int CompareTo(Single value) => Decrypt.CompareTo(value); + public int CompareTo(object value) => Decrypt.CompareTo(value); + public override bool Equals(object obj) => Decrypt.Equals(obj); + public bool Equals(Single obj) => Decrypt.Equals(obj); + public override int GetHashCode() => Decrypt.GetHashCode(); + public TypeCode GetTypeCode() => Decrypt.GetTypeCode(); + public override string ToString() => Decrypt.ToString(); + public string ToString(IFormatProvider provider) => Decrypt.ToString(provider); + public string ToString(string format) => Decrypt.ToString(format); + public string ToString(string format, IFormatProvider provider) => Decrypt.ToString(format, provider); #endregion #region Operators Overloading /// + - * / % - public static EncFloat operator +(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Value + eint2.Value); - public static EncFloat operator -(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Value - eint2.Value); - public static EncFloat operator *(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Value * eint2.Value); - public static EncFloat operator /(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Value / eint2.Value); - public static EncFloat operator %(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Value % eint2.Value); - - public static float operator +(EncFloat efloat1, ulong efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, ulong efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, ulong efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, ulong efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, ulong efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, long efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, long efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, long efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, long efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, long efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, uint efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, uint efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, uint efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, uint efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, uint efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, int efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, int efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, int efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, int efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, int efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, ushort efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, ushort efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, ushort efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, ushort efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, ushort efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, short efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, short efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, short efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, short efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, short efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, byte efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, byte efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, byte efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, byte efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, byte efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, sbyte efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, sbyte efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, sbyte efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, sbyte efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, sbyte efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, float efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, float efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, float efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, float efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, float efloat2) => efloat1.Value % efloat2; + public static EncFloat operator +(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Decrypt + eint2.Decrypt); + public static EncFloat operator -(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Decrypt - eint2.Decrypt); + public static EncFloat operator *(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Decrypt * eint2.Decrypt); + public static EncFloat operator /(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Decrypt / eint2.Decrypt); + public static EncFloat operator %(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Decrypt % eint2.Decrypt); + + public static float operator +(EncFloat efloat1, ulong efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, ulong efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, ulong efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, ulong efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, ulong efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, long efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, long efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, long efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, long efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, long efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, uint efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, uint efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, uint efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, uint efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, uint efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, int efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, int efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, int efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, int efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, int efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, ushort efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, ushort efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, ushort efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, ushort efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, ushort efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, short efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, short efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, short efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, short efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, short efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, byte efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, byte efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, byte efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, byte efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, byte efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, sbyte efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, sbyte efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, sbyte efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, sbyte efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, sbyte efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, float efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, float efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, float efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, float efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, float efloat2) => efloat1.Decrypt % efloat2; /// == != < > - public static bool operator ==(EncFloat eint1, EncFloat eint2) => eint1.Value == eint2.Value; - public static bool operator !=(EncFloat eint1, EncFloat eint2) => eint1.Value != eint2.Value; - public static bool operator <(EncFloat eint1, EncFloat eint2) => eint1.Value < eint2.Value; - public static bool operator >(EncFloat eint1, EncFloat eint2) => eint1.Value > eint2.Value; - - public static bool operator ==(EncFloat eint1, ulong eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, ulong eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, ulong eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, ulong eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, long eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, long eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, long eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, long eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, uint eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, uint eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, uint eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, uint eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, int eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, int eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, int eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, int eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, ushort eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, ushort eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, ushort eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, ushort eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, short eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, short eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, short eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, short eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, byte eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, byte eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, byte eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, byte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, sbyte eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, sbyte eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, sbyte eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, sbyte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, decimal eint2) => (decimal)eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, decimal eint2) => (decimal)eint1.Value != eint2; - public static bool operator >(EncFloat eint1, decimal eint2) => (decimal)eint1.Value > eint2; - public static bool operator <(EncFloat eint1, decimal eint2) => (decimal)eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, double eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, double eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, double eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, double eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, float eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, float eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, float eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, float eint2) => eint1.Value < eint2; + public static bool operator ==(EncFloat eint1, EncFloat eint2) => eint1.Decrypt == eint2.Decrypt; + public static bool operator !=(EncFloat eint1, EncFloat eint2) => eint1.Decrypt != eint2.Decrypt; + public static bool operator <(EncFloat eint1, EncFloat eint2) => eint1.Decrypt < eint2.Decrypt; + public static bool operator >(EncFloat eint1, EncFloat eint2) => eint1.Decrypt > eint2.Decrypt; + + public static bool operator ==(EncFloat eint1, ulong eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, ulong eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, ulong eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, ulong eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, long eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, long eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, long eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, long eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, uint eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, uint eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, uint eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, uint eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, int eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, int eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, int eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, int eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, ushort eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, ushort eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, ushort eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, ushort eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, short eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, short eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, short eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, short eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, byte eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, byte eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, byte eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, byte eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, sbyte eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, sbyte eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, sbyte eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, sbyte eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, decimal eint2) => (decimal)eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, decimal eint2) => (decimal)eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, decimal eint2) => (decimal)eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, decimal eint2) => (decimal)eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, double eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, double eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, double eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, double eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, float eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, float eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, float eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, float eint2) => eint1.Decrypt < eint2; /// assign public static implicit operator EncFloat(ulong value) => new EncFloat(value); @@ -204,17 +215,17 @@ private EncFloat(float value) public static explicit operator EncFloat(double value) => new EncFloat((float)value); public static implicit operator EncFloat(float value) => new EncFloat(value); - public static explicit operator decimal(EncFloat eint1) => (decimal)eint1.Value; - public static implicit operator double(EncFloat eint1) => eint1.Value; - public static implicit operator float(EncFloat eint1) => eint1.Value; - public static explicit operator ulong(EncFloat eint1) => (ulong)eint1.Value; - public static explicit operator long(EncFloat eint1) => (long)eint1.Value; - public static explicit operator uint(EncFloat eint1) => (uint)eint1.Value; - public static explicit operator int(EncFloat eint1) => (int)eint1.Value; - public static explicit operator ushort(EncFloat eint1) => (ushort)eint1.Value; - public static explicit operator short(EncFloat eint1) => (short)eint1.Value; - public static explicit operator byte(EncFloat eint1) => (byte)eint1.Value; - public static explicit operator sbyte(EncFloat eint1) => (sbyte)eint1.Value; + public static explicit operator decimal(EncFloat eint1) => (decimal)eint1.Decrypt; + public static implicit operator double(EncFloat eint1) => eint1.Decrypt; + public static implicit operator float(EncFloat eint1) => eint1.Decrypt; + public static explicit operator ulong(EncFloat eint1) => (ulong)eint1.Decrypt; + public static explicit operator long(EncFloat eint1) => (long)eint1.Decrypt; + public static explicit operator uint(EncFloat eint1) => (uint)eint1.Decrypt; + public static explicit operator int(EncFloat eint1) => (int)eint1.Decrypt; + public static explicit operator ushort(EncFloat eint1) => (ushort)eint1.Decrypt; + public static explicit operator short(EncFloat eint1) => (short)eint1.Decrypt; + public static explicit operator byte(EncFloat eint1) => (byte)eint1.Decrypt; + public static explicit operator sbyte(EncFloat eint1) => (sbyte)eint1.Decrypt; #endregion } \ No newline at end of file diff --git a/Benchmark/Solution/Variable-Encryption/Types/EncInt.cs b/Benchmark/Solution/Variable-Encryption/Types/EncInt.cs index 05b6a2d..9634cb5 100644 --- a/Benchmark/Solution/Variable-Encryption/Types/EncInt.cs +++ b/Benchmark/Solution/Variable-Encryption/Types/EncInt.cs @@ -5,24 +5,30 @@ public struct EncInt /// A struct for storing a 32-bit integer while efficiently keeping it encrypted in the memory /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted /// The encryption will happen in the background without you worrying about it - /// In the memory it is saved as a weird floating-point number that is affected by random values { encryptionKey1 & encryptionKey2 } + /// In the memory it is saved as a an array of weird bytes that are affected by random values { encryptionKeys array } /// Every time the value changes, the encryption keys change too. And it works exactly as an int (Int32) /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties - // The encryption values - private readonly double encryptionKey1; - private readonly double encryptionKey2; + private readonly byte[] encryptionKeys; // The encrypted value stored in memory - private readonly double encryptedValue; + private readonly byte[] encryptedValue; - // The decrypted value - private int Value + // Takes an encrypted value and returns it decrypted + private int Decrypt { - get => (int)Decrypt(); + get + { + var valueBytes = new byte[4]; + for (int i = 0; i < 4; i++) + { + valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); + } + return BitConverter.ToInt32(valueBytes); + } } public static int MaxValue { get => Int32.MaxValue; } @@ -34,144 +40,149 @@ private int Value private EncInt(int value) { - encryptionKey1 = random.NextDouble() * 0.01; - encryptionKey2 = random.NextDouble() * 10; - encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + encryptionKeys = new byte[4]; + encryptedValue = Encrypt(value, encryptionKeys); } // Encryption Key Generator static private Random random = new Random(); // Takes a given value and returns it encrypted - private static double Encrypt(double value, double k1, double k2) => (value * k1) * k2; - - // Takes an encrypted value and returns it decrypted - private double Decrypt() => ((encryptedValue / encryptionKey2) / encryptionKey1) + 0.5; + private static byte[] Encrypt(int value, byte[] keys) + { + random.NextBytes(keys); + var valueBytes = BitConverter.GetBytes(value); + for (int i = 0; i < 4; i++) + { + valueBytes[i] ^= keys[i]; + } + return valueBytes; + } // Int32 methods - public Int32 CompareTo(object value) => Value.CompareTo(value); - public Int32 CompareTo(Int32 value) => Value.CompareTo(value); - public bool Equals(Int32 obj) => Value.Equals(obj); - public override bool Equals(object obj) => Value.Equals(obj); - public override Int32 GetHashCode() => Value.GetHashCode(); - public TypeCode GetTypeCode() => Value.GetTypeCode(); - public override string ToString() => Value.ToString(); - public string ToString(IFormatProvider provider) => Value.ToString(provider); - public string ToString(string format) => Value.ToString(format); - public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + public Int32 CompareTo(object value) => Decrypt.CompareTo(value); + public Int32 CompareTo(Int32 value) => Decrypt.CompareTo(value); + public bool Equals(Int32 obj) => Decrypt.Equals(obj); + public override bool Equals(object obj) => Decrypt.Equals(obj); + public override Int32 GetHashCode() => Decrypt.GetHashCode(); + public TypeCode GetTypeCode() => Decrypt.GetTypeCode(); + public override string ToString() => Decrypt.ToString(); + public string ToString(IFormatProvider provider) => Decrypt.ToString(provider); + public string ToString(string format) => Decrypt.ToString(format); + public string ToString(string format, IFormatProvider provider) => Decrypt.ToString(format, provider); #endregion #region Operators Overloading /// & | ^ << >> - public static EncInt operator &(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value & eint2.Value); - public static EncInt operator |(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value | eint2.Value); - public static EncInt operator ^(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value ^ eint2.Value); + public static EncInt operator &(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt & eint2.Decrypt); + public static EncInt operator |(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt | eint2.Decrypt); + public static EncInt operator ^(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt ^ eint2.Decrypt); - public static int operator &(EncInt eint1, int eint2) => eint1.Value & eint2; - public static int operator |(EncInt eint1, int eint2) => eint1.Value | eint2; - public static int operator ^(EncInt eint1, int eint2) => eint1.Value ^ eint2; - public static int operator >>(EncInt eint1, int eint2) => eint1.Value >> eint2; - public static int operator <<(EncInt eint1, int eint2) => eint1.Value << eint2; + public static int operator &(EncInt eint1, int eint2) => eint1.Decrypt & eint2; + public static int operator |(EncInt eint1, int eint2) => eint1.Decrypt | eint2; + public static int operator ^(EncInt eint1, int eint2) => eint1.Decrypt ^ eint2; + public static int operator >>(EncInt eint1, int eint2) => eint1.Decrypt >> eint2; + public static int operator <<(EncInt eint1, int eint2) => eint1.Decrypt << eint2; /// + - * / % - public static EncInt operator +(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value + eint2.Value); - public static EncInt operator -(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value - eint2.Value); - public static EncInt operator *(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value * eint2.Value); - public static EncInt operator /(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value / eint2.Value); - public static EncInt operator %(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value % eint2.Value); - - public static int operator +(EncInt eint1, int eint2) => eint1.Value + eint2; - public static int operator -(EncInt eint1, int eint2) => eint1.Value - eint2; - public static int operator *(EncInt eint1, int eint2) => eint1.Value * eint2; - public static int operator /(EncInt eint1, int eint2) => eint1.Value / eint2; - public static int operator %(EncInt eint1, int eint2) => eint1.Value % eint2; - - public static int operator +(EncInt eint1, ushort eint2) => eint1.Value + eint2; - public static int operator -(EncInt eint1, ushort eint2) => eint1.Value - eint2; - public static int operator *(EncInt eint1, ushort eint2) => eint1.Value * eint2; - public static int operator /(EncInt eint1, ushort eint2) => eint1.Value / eint2; - public static int operator %(EncInt eint1, ushort eint2) => eint1.Value % eint2; - - public static int operator +(EncInt eint1, short eint2) => eint1.Value + eint2; - public static int operator -(EncInt eint1, short eint2) => eint1.Value - eint2; - public static int operator *(EncInt eint1, short eint2) => eint1.Value * eint2; - public static int operator /(EncInt eint1, short eint2) => eint1.Value / eint2; - public static int operator %(EncInt eint1, short eint2) => eint1.Value % eint2; - - public static int operator +(EncInt eint1, byte eint2) => eint1.Value + eint2; - public static int operator -(EncInt eint1, byte eint2) => eint1.Value - eint2; - public static int operator *(EncInt eint1, byte eint2) => eint1.Value * eint2; - public static int operator /(EncInt eint1, byte eint2) => eint1.Value / eint2; - public static int operator %(EncInt eint1, byte eint2) => eint1.Value % eint2; - - public static int operator +(EncInt eint1, sbyte eint2) => eint1.Value + eint2; - public static int operator -(EncInt eint1, sbyte eint2) => eint1.Value - eint2; - public static int operator *(EncInt eint1, sbyte eint2) => eint1.Value * eint2; - public static int operator /(EncInt eint1, sbyte eint2) => eint1.Value / eint2; - public static int operator %(EncInt eint1, sbyte eint2) => eint1.Value % eint2; + public static EncInt operator +(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt + eint2.Decrypt); + public static EncInt operator -(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt - eint2.Decrypt); + public static EncInt operator *(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt * eint2.Decrypt); + public static EncInt operator /(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt / eint2.Decrypt); + public static EncInt operator %(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt % eint2.Decrypt); + + public static int operator +(EncInt eint1, int eint2) => eint1.Decrypt + eint2; + public static int operator -(EncInt eint1, int eint2) => eint1.Decrypt - eint2; + public static int operator *(EncInt eint1, int eint2) => eint1.Decrypt * eint2; + public static int operator /(EncInt eint1, int eint2) => eint1.Decrypt / eint2; + public static int operator %(EncInt eint1, int eint2) => eint1.Decrypt % eint2; + + public static int operator +(EncInt eint1, ushort eint2) => eint1.Decrypt + eint2; + public static int operator -(EncInt eint1, ushort eint2) => eint1.Decrypt - eint2; + public static int operator *(EncInt eint1, ushort eint2) => eint1.Decrypt * eint2; + public static int operator /(EncInt eint1, ushort eint2) => eint1.Decrypt / eint2; + public static int operator %(EncInt eint1, ushort eint2) => eint1.Decrypt % eint2; + + public static int operator +(EncInt eint1, short eint2) => eint1.Decrypt + eint2; + public static int operator -(EncInt eint1, short eint2) => eint1.Decrypt - eint2; + public static int operator *(EncInt eint1, short eint2) => eint1.Decrypt * eint2; + public static int operator /(EncInt eint1, short eint2) => eint1.Decrypt / eint2; + public static int operator %(EncInt eint1, short eint2) => eint1.Decrypt % eint2; + + public static int operator +(EncInt eint1, byte eint2) => eint1.Decrypt + eint2; + public static int operator -(EncInt eint1, byte eint2) => eint1.Decrypt - eint2; + public static int operator *(EncInt eint1, byte eint2) => eint1.Decrypt * eint2; + public static int operator /(EncInt eint1, byte eint2) => eint1.Decrypt / eint2; + public static int operator %(EncInt eint1, byte eint2) => eint1.Decrypt % eint2; + + public static int operator +(EncInt eint1, sbyte eint2) => eint1.Decrypt + eint2; + public static int operator -(EncInt eint1, sbyte eint2) => eint1.Decrypt - eint2; + public static int operator *(EncInt eint1, sbyte eint2) => eint1.Decrypt * eint2; + public static int operator /(EncInt eint1, sbyte eint2) => eint1.Decrypt / eint2; + public static int operator %(EncInt eint1, sbyte eint2) => eint1.Decrypt % eint2; /// == != < > - public static bool operator ==(EncInt eint1, EncInt eint2) => eint1.Value == eint2.Value; - public static bool operator !=(EncInt eint1, EncInt eint2) => eint1.Value != eint2.Value; - public static bool operator <(EncInt eint1, EncInt eint2) => eint1.Value < eint2.Value; - public static bool operator >(EncInt eint1, EncInt eint2) => eint1.Value > eint2.Value; - - public static bool operator ==(EncInt eint1, ulong eint2) => (ulong)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, ulong eint2) => (ulong)eint1.Value != eint2; - public static bool operator >(EncInt eint1, ulong eint2) => (ulong)eint1.Value > eint2; - public static bool operator <(EncInt eint1, ulong eint2) => (ulong)eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, long eint2) => eint1.Value == eint2; - public static bool operator !=(EncInt eint1, long eint2) => eint1.Value != eint2; - public static bool operator >(EncInt eint1, long eint2) => eint1.Value > eint2; - public static bool operator <(EncInt eint1, long eint2) => eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, uint eint2) => (uint)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, uint eint2) => (uint)eint1.Value != eint2; - public static bool operator >(EncInt eint1, uint eint2) => (uint)eint1.Value > eint2; - public static bool operator <(EncInt eint1, uint eint2) => (uint)eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, int eint2) => eint1.Value == eint2; - public static bool operator !=(EncInt eint1, int eint2) => eint1.Value != eint2; - public static bool operator >(EncInt eint1, int eint2) => eint1.Value > eint2; - public static bool operator <(EncInt eint1, int eint2) => eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, ushort eint2) => (ushort)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, ushort eint2) => (ushort)eint1.Value != eint2; - public static bool operator >(EncInt eint1, ushort eint2) => (ushort)eint1.Value > eint2; - public static bool operator <(EncInt eint1, ushort eint2) => (ushort)eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, short eint2) => (short)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, short eint2) => (short)eint1.Value != eint2; - public static bool operator >(EncInt eint1, short eint2) => (short)eint1.Value > eint2; - public static bool operator <(EncInt eint1, short eint2) => (short)eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, byte eint2) => (byte)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, byte eint2) => (byte)eint1.Value != eint2; - public static bool operator >(EncInt eint1, byte eint2) => (byte)eint1.Value > eint2; - public static bool operator <(EncInt eint1, byte eint2) => (byte)eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value != eint2; - public static bool operator >(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value > eint2; - public static bool operator <(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, decimal eint2) => eint1.Value == eint2; - public static bool operator !=(EncInt eint1, decimal eint2) => eint1.Value != eint2; - public static bool operator >(EncInt eint1, decimal eint2) => eint1.Value > eint2; - public static bool operator <(EncInt eint1, decimal eint2) => eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, double eint2) => eint1.Value == eint2; - public static bool operator !=(EncInt eint1, double eint2) => eint1.Value != eint2; - public static bool operator >(EncInt eint1, double eint2) => eint1.Value > eint2; - public static bool operator <(EncInt eint1, double eint2) => eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, float eint2) => eint1.Value == eint2; - public static bool operator !=(EncInt eint1, float eint2) => eint1.Value != eint2; - public static bool operator >(EncInt eint1, float eint2) => eint1.Value > eint2; - public static bool operator <(EncInt eint1, float eint2) => eint1.Value < eint2; + public static bool operator ==(EncInt eint1, EncInt eint2) => eint1.Decrypt == eint2.Decrypt; + public static bool operator !=(EncInt eint1, EncInt eint2) => eint1.Decrypt != eint2.Decrypt; + public static bool operator <(EncInt eint1, EncInt eint2) => eint1.Decrypt < eint2.Decrypt; + public static bool operator >(EncInt eint1, EncInt eint2) => eint1.Decrypt > eint2.Decrypt; + + public static bool operator ==(EncInt eint1, ulong eint2) => (ulong)eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, ulong eint2) => (ulong)eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, ulong eint2) => (ulong)eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, ulong eint2) => (ulong)eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, long eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, long eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, long eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, long eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, uint eint2) => (uint)eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, uint eint2) => (uint)eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, uint eint2) => (uint)eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, uint eint2) => (uint)eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, int eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, int eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, int eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, int eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, ushort eint2) => (ushort)eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, ushort eint2) => (ushort)eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, ushort eint2) => (ushort)eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, ushort eint2) => (ushort)eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, short eint2) => (short)eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, short eint2) => (short)eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, short eint2) => (short)eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, short eint2) => (short)eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, byte eint2) => (byte)eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, byte eint2) => (byte)eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, byte eint2) => (byte)eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, byte eint2) => (byte)eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, sbyte eint2) => (sbyte)eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, sbyte eint2) => (sbyte)eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, sbyte eint2) => (sbyte)eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, sbyte eint2) => (sbyte)eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, decimal eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, decimal eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, decimal eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, decimal eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, double eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, double eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, double eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, double eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, float eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, float eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, float eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, float eint2) => eint1.Decrypt < eint2; /// assign public static explicit operator EncInt(ulong value) => new EncInt((int)value); @@ -186,17 +197,17 @@ private EncInt(int value) public static explicit operator EncInt(double value) => new EncInt((int)value); public static explicit operator EncInt(float value) => new EncInt((int)value); - public static explicit operator ulong(EncInt eint1) => (ulong)eint1.Value; - public static implicit operator long(EncInt eint1) => eint1.Value; - public static explicit operator uint(EncInt eint1) => (uint)eint1.Value; - public static implicit operator int(EncInt eint1) => eint1.Value; - public static explicit operator ushort(EncInt eint1) => (ushort)eint1.Value; - public static explicit operator short(EncInt eint1) => (short)eint1.Value; - public static explicit operator byte(EncInt eint1) => (byte)eint1.Value; - public static explicit operator sbyte(EncInt eint1) => (sbyte)eint1.Value; - public static implicit operator decimal(EncInt eint1) => eint1.Value; - public static implicit operator double(EncInt eint1) => eint1.Value; - public static implicit operator float(EncInt eint1) => eint1.Value; + public static explicit operator ulong(EncInt eint1) => (ulong)eint1.Decrypt; + public static implicit operator long(EncInt eint1) => eint1.Decrypt; + public static explicit operator uint(EncInt eint1) => (uint)eint1.Decrypt; + public static implicit operator int(EncInt eint1) => eint1.Decrypt; + public static explicit operator ushort(EncInt eint1) => (ushort)eint1.Decrypt; + public static explicit operator short(EncInt eint1) => (short)eint1.Decrypt; + public static explicit operator byte(EncInt eint1) => (byte)eint1.Decrypt; + public static explicit operator sbyte(EncInt eint1) => (sbyte)eint1.Decrypt; + public static implicit operator decimal(EncInt eint1) => eint1.Decrypt; + public static implicit operator double(EncInt eint1) => eint1.Decrypt; + public static implicit operator float(EncInt eint1) => eint1.Decrypt; #endregion } \ No newline at end of file diff --git a/Benchmark/Solution/Variable-Encryption/Types/EncLong.cs b/Benchmark/Solution/Variable-Encryption/Types/EncLong.cs index 352edbd..d2d1795 100644 --- a/Benchmark/Solution/Variable-Encryption/Types/EncLong.cs +++ b/Benchmark/Solution/Variable-Encryption/Types/EncLong.cs @@ -17,10 +17,18 @@ public struct EncLong // The encrypted value stored in memory private readonly byte[] encryptedValue; - // The decrypted value - private long Value + // Takes an encrypted value and returns it decrypted + private long Decrypt { - get => Decrypt(); + get + { + var valueBytes = new byte[8]; + for (int i = 0; i < 8; i++) + { + valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); + } + return BitConverter.ToInt64(valueBytes); + } } public static long MaxValue { get => Int64.MaxValue; } @@ -33,7 +41,6 @@ private long Value private EncLong(long value) { encryptionKeys = new byte[8]; - random.NextBytes(encryptionKeys); encryptedValue = Encrypt(value, encryptionKeys); } @@ -43,6 +50,7 @@ private EncLong(long value) // Takes a given value and returns it encrypted private static byte[] Encrypt(long value, byte[] keys) { + random.NextBytes(keys); var valueBytes = BitConverter.GetBytes(value); for (int i = 0; i < 8; i++) { @@ -51,133 +59,122 @@ private static byte[] Encrypt(long value, byte[] keys) return valueBytes; } - // Takes an encrypted value and returns it decrypted - private long Decrypt() - { - var valueBytes = new byte[8]; - for (int i = 0; i < 8; i++) - { - valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); - } - return BitConverter.ToInt64(valueBytes); - } - // Int64 methods - public int CompareTo(object value) => Value.CompareTo(value); - public int CompareTo(long value) => Value.CompareTo(value); - public bool Equals(long obj) => Value.Equals(obj); - public override bool Equals(object obj) => Value.Equals(obj); - public override int GetHashCode() => Value.GetHashCode(); - public TypeCode GetTypeCode() => Value.GetTypeCode(); - public override string ToString() => Value.ToString(); - public string ToString(IFormatProvider provider) => Value.ToString(provider); - public string ToString(string format) => Value.ToString(format); - public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + public int CompareTo(object value) => Decrypt.CompareTo(value); + public int CompareTo(long value) => Decrypt.CompareTo(value); + public bool Equals(long obj) => Decrypt.Equals(obj); + public override bool Equals(object obj) => Decrypt.Equals(obj); + public override int GetHashCode() => Decrypt.GetHashCode(); + public TypeCode GetTypeCode() => Decrypt.GetTypeCode(); + public override string ToString() => Decrypt.ToString(); + public string ToString(IFormatProvider provider) => Decrypt.ToString(provider); + public string ToString(string format) => Decrypt.ToString(format); + public string ToString(string format, IFormatProvider provider) => Decrypt.ToString(format, provider); #endregion #region Operators Overloading /// & | ^ - public static EncLong operator &(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value & elong2.Value); - public static EncLong operator |(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value | elong2.Value); - public static EncLong operator ^(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value ^ elong2.Value); + public static EncLong operator &(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt & elong2.Decrypt); + public static EncLong operator |(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt | elong2.Decrypt); + public static EncLong operator ^(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt ^ elong2.Decrypt); - public static long operator &(EncLong elong1, long elong2) => elong1.Value & elong2; - public static long operator |(EncLong elong1, long elong2) => elong1.Value | elong2; - public static long operator ^(EncLong elong1, long elong2) => elong1.Value ^ elong2; + public static long operator &(EncLong elong1, long elong2) => elong1.Decrypt & elong2; + public static long operator |(EncLong elong1, long elong2) => elong1.Decrypt | elong2; + public static long operator ^(EncLong elong1, long elong2) => elong1.Decrypt ^ elong2; /// + - * / % - public static EncLong operator +(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value + elong2.Value); - public static EncLong operator -(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value - elong2.Value); - public static EncLong operator *(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value * elong2.Value); - public static EncLong operator /(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value / elong2.Value); - public static EncLong operator %(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value % elong2.Value); - - public static long operator +(EncLong elong1, long elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, long elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, long elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, long elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, long elong2) => elong1.Value % elong2; - - public static long operator +(EncLong elong1, int elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, int elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, int elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, int elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, int elong2) => elong1.Value % elong2; - - public static long operator +(EncLong elong1, short elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, short elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, short elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, short elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, short elong2) => elong1.Value % elong2; - - public static long operator +(EncLong elong1, ushort elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, ushort elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, ushort elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, ushort elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, ushort elong2) => elong1.Value % elong2; - - public static long operator +(EncLong elong1, uint elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, uint elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, uint elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, uint elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, uint elong2) => elong1.Value % elong2; - - public static long operator +(EncLong elong1, byte elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, byte elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, byte elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, byte elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, byte elong2) => elong1.Value % elong2; - - public static long operator +(EncLong elong1, sbyte elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, sbyte elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, sbyte elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, sbyte elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, sbyte elong2) => elong1.Value % elong2; + public static EncLong operator +(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt + elong2.Decrypt); + public static EncLong operator -(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt - elong2.Decrypt); + public static EncLong operator *(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt * elong2.Decrypt); + public static EncLong operator /(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt / elong2.Decrypt); + public static EncLong operator %(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt % elong2.Decrypt); + + public static long operator +(EncLong elong1, long elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, long elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, long elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, long elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, long elong2) => elong1.Decrypt % elong2; + + public static long operator +(EncLong elong1, int elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, int elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, int elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, int elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, int elong2) => elong1.Decrypt % elong2; + + public static long operator +(EncLong elong1, short elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, short elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, short elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, short elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, short elong2) => elong1.Decrypt % elong2; + + public static long operator +(EncLong elong1, ushort elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, ushort elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, ushort elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, ushort elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, ushort elong2) => elong1.Decrypt % elong2; + + public static long operator +(EncLong elong1, uint elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, uint elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, uint elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, uint elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, uint elong2) => elong1.Decrypt % elong2; + + public static long operator +(EncLong elong1, byte elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, byte elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, byte elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, byte elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, byte elong2) => elong1.Decrypt % elong2; + + public static long operator +(EncLong elong1, sbyte elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, sbyte elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, sbyte elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, sbyte elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, sbyte elong2) => elong1.Decrypt % elong2; /// == != < > /// - public static bool operator ==(EncLong elong1, byte elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, byte elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, byte elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, byte elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, sbyte elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, sbyte elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, sbyte elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, sbyte elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, short elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, short elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, short elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, short elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, ushort elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, ushort elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, ushort elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, ushort elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, uint elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, uint elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, uint elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, uint elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, int elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, int elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, int elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, int elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, long elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, long elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, long elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, long elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, EncLong elong2) => elong1.Value == elong2.Value; - public static bool operator !=(EncLong elong1, EncLong elong2) => elong1.Value != elong2.Value; - public static bool operator <(EncLong elong1, EncLong elong2) => elong1.Value < elong2.Value; - public static bool operator >(EncLong elong1, EncLong elong2) => elong1.Value > elong2.Value; + public static bool operator ==(EncLong elong1, byte elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, byte elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, byte elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, byte elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, sbyte elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, sbyte elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, sbyte elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, sbyte elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, short elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, short elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, short elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, short elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, ushort elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, ushort elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, ushort elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, ushort elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, uint elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, uint elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, uint elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, uint elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, int elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, int elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, int elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, int elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, long elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, long elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, long elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, long elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, EncLong elong2) => elong1.Decrypt == elong2.Decrypt; + public static bool operator !=(EncLong elong1, EncLong elong2) => elong1.Decrypt != elong2.Decrypt; + public static bool operator <(EncLong elong1, EncLong elong2) => elong1.Decrypt < elong2.Decrypt; + public static bool operator >(EncLong elong1, EncLong elong2) => elong1.Decrypt > elong2.Decrypt; /// assign public static explicit operator EncLong(ulong value) => new EncLong((long)value); @@ -192,17 +189,17 @@ private long Decrypt() public static explicit operator EncLong(double value) => new EncLong((long)value); public static explicit operator EncLong(float value) => new EncLong((long)value); - public static explicit operator ulong(EncLong elong1) => (ulong)elong1.Value; - public static implicit operator long(EncLong elong1) => elong1.Value; - public static explicit operator uint(EncLong elong1) => (uint)elong1.Value; - public static explicit operator int(EncLong elong1) => (int)elong1.Value; - public static explicit operator ushort(EncLong elong1) => (ushort)elong1.Value; - public static explicit operator short(EncLong elong1) => (short)elong1.Value; - public static explicit operator byte(EncLong elong1) => (byte)elong1.Value; - public static explicit operator sbyte(EncLong elong1) => (sbyte)elong1.Value; - public static implicit operator decimal(EncLong elong1) => elong1.Value; - public static implicit operator double(EncLong elong1) => elong1.Value; - public static implicit operator float(EncLong elong1) => elong1.Value; + public static explicit operator ulong(EncLong elong1) => (ulong)elong1.Decrypt; + public static implicit operator long(EncLong elong1) => elong1.Decrypt; + public static explicit operator uint(EncLong elong1) => (uint)elong1.Decrypt; + public static explicit operator int(EncLong elong1) => (int)elong1.Decrypt; + public static explicit operator ushort(EncLong elong1) => (ushort)elong1.Decrypt; + public static explicit operator short(EncLong elong1) => (short)elong1.Decrypt; + public static explicit operator byte(EncLong elong1) => (byte)elong1.Decrypt; + public static explicit operator sbyte(EncLong elong1) => (sbyte)elong1.Decrypt; + public static implicit operator decimal(EncLong elong1) => elong1.Decrypt; + public static implicit operator double(EncLong elong1) => elong1.Decrypt; + public static implicit operator float(EncLong elong1) => elong1.Decrypt; #endregion } \ No newline at end of file From d40bca65fa78f64c1667dd1b78842ea58a3244ba Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 16:22:28 +0200 Subject: [PATCH 48/53] Benchmark update - When you compare strings the benchmark will be 50 times faster - Updated the section that shows the size of each EncType in bytes --- .../Variable-Encryption/Benchmark/BenchmarkData.cs | 2 +- .../Variable-Encryption/Benchmark/VarEncBenchmark.cs | 8 +++----- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkData.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkData.cs index f8e753b..388c531 100644 --- a/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkData.cs +++ b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarkData.cs @@ -62,7 +62,7 @@ public void InputPreset(BenchmarkPreset benchmarkPreset, string presetGroupName, { if (ComparingStrings) { - changesAmount = benchmarkPreset.ChangesAmount / 100; + changesAmount = benchmarkPreset.ChangesAmount / 50; } else { diff --git a/Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs index 1e91a79..b942c58 100644 --- a/Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs +++ b/Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs @@ -187,7 +187,7 @@ public static void PrintBenchmarkPresetGroup() int number = i + 1; int changesAmount = (currentBenchmarkData.ComparingStrings) - ? group.presets[i].ChangesAmount / 100 + ? group.presets[i].ChangesAmount / 50 : group.presets[i].ChangesAmount; string[] lines = @@ -209,18 +209,16 @@ public static void PrintSizesOfTypes() SeparationLine(); WriteLine("These are the sizes of each type, in bytes."); - WriteLine("EncInt & EncFloat use a different method for encryption. Large size in memory, but 150% more efficient."); - WriteLine("These are the only types this method can work on."); SeparationLineSmall(); WriteLine("int size: {0}", 4); - WriteLine("EncInt size: {0}", 24); + WriteLine("EncInt size: {0}", 8); WriteLine(); WriteLine("long size: {0}", 8); WriteLine("EncLong size: {0}", 16); WriteLine(); WriteLine("float size: {0}", 4); - WriteLine("EncFloat size: {0}", 24); + WriteLine("EncFloat size: {0}", 8); WriteLine(); WriteLine("double size: {0}", 8); WriteLine("EncDouble size: {0}", 16); From f1ee0756b35b80cd8c310f89df82bccd98e8e081 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 19:18:52 +0200 Subject: [PATCH 49/53] Updated EncTypes --- EncTypes/EncDecimal.cs | 331 ++++++++++++++++++++--------------------- EncTypes/EncDouble.cs | 316 +++++++++++++++++++-------------------- EncTypes/EncFloat.cs | 324 +++++++++++++++++++++------------------- EncTypes/EncInt.cs | 287 ++++++++++++++++++----------------- EncTypes/EncLong.cs | 253 ++++++++++++++++--------------- 5 files changed, 762 insertions(+), 749 deletions(-) diff --git a/EncTypes/EncDecimal.cs b/EncTypes/EncDecimal.cs index 0aec94f..b77f726 100644 --- a/EncTypes/EncDecimal.cs +++ b/EncTypes/EncDecimal.cs @@ -2,11 +2,11 @@ public struct EncDecimal { - /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory. + /// A struct for storing a Decimal while efficiently keeping it encrypted in the memory /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted /// The encryption will happen in the background without you worrying about it /// In the memory it is saved as a an array of weird bytes that are affected by random values { encryptionKeys array } - /// Every time the value changes, the encryption keys change too. And it works exactly as a deciaml. + /// Every time the value changes, the encryption keys change too. And it works exactly as a deciaml /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc @@ -17,10 +17,18 @@ public struct EncDecimal // The encrypted value stored in memory private readonly int[] encryptedValue; - // The decrypted value - private decimal Value + // Takes an encrypted value and returns it decrypted + private decimal Decrypt { - get => Decrypt(); + get + { + var decrypted = new int[4]; + for (int i = 0; i < 4; i++) + { + decrypted[i] = encryptedValue[i] ^ encryptionKeys[i]; + } + return new decimal(decrypted); + } } public static Decimal MaxValue { get => Decimal.MaxValue; } @@ -63,28 +71,17 @@ private static int[] Encrypt(decimal value, int[] keys) return valueInBits; } - // Takes an encrypted value and returns it decrypted - private decimal Decrypt() - { - var decrypted = new int[4]; - for (int i = 0; i < 4; i++) - { - decrypted[i] = encryptedValue[i] ^ encryptionKeys[i]; - } - return new decimal(decrypted); - } - // Overrides - public int CompareTo(Decimal value) => Value.CompareTo(value); - public int CompareTo(object value) => Value.CompareTo(value); - public bool Equals(Decimal value) => Value.Equals(value); - public override bool Equals(object value) => Value.Equals(value); - public override int GetHashCode() => Value.GetHashCode(); - public TypeCode GetTypeCode() => Value.GetTypeCode(); - public string ToString(string format) => Value.ToString(format); - public string ToString(IFormatProvider provider) => Value.ToString(provider); - public override string ToString() => Value.ToString(); - public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + public int CompareTo(Decimal value) => Decrypt.CompareTo(value); + public int CompareTo(object value) => Decrypt.CompareTo(value); + public bool Equals(Decimal value) => Decrypt.Equals(value); + public override bool Equals(object value) => Decrypt.Equals(value); + public override int GetHashCode() => Decrypt.GetHashCode(); + public TypeCode GetTypeCode() => Decrypt.GetTypeCode(); + public string ToString(string format) => Decrypt.ToString(format); + public string ToString(IFormatProvider provider) => Decrypt.ToString(provider); + public override string ToString() => Decrypt.ToString(); + public string ToString(string format, IFormatProvider provider) => Decrypt.ToString(format, provider); #endregion @@ -92,139 +89,139 @@ private decimal Decrypt() /// + - * / % - public static EncDecimal operator +(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Value + eint2.Value); - public static EncDecimal operator -(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Value - eint2.Value); - public static EncDecimal operator *(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Value * eint2.Value); - public static EncDecimal operator /(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Value / eint2.Value); - public static EncDecimal operator %(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Value % eint2.Value); - - public static decimal operator +(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, long edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, long edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, long edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, long edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, long edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, int edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, int edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, int edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, int edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, int edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, short edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, short edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, short edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, short edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, short edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value + edecimal2; - public static decimal operator -(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value - edecimal2; - public static decimal operator *(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value * edecimal2; - public static decimal operator /(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value / edecimal2; - public static decimal operator %(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value % edecimal2; - - public static decimal operator +(EncDecimal edecimal1, double edecimal2) => edecimal1.Value + (decimal)edecimal2; - public static decimal operator -(EncDecimal edecimal1, double edecimal2) => edecimal1.Value - (decimal)edecimal2; - public static decimal operator *(EncDecimal edecimal1, double edecimal2) => edecimal1.Value * (decimal)edecimal2; - public static decimal operator /(EncDecimal edecimal1, double edecimal2) => edecimal1.Value / (decimal)edecimal2; - public static decimal operator %(EncDecimal edecimal1, double edecimal2) => edecimal1.Value % (decimal)edecimal2; - - public static decimal operator +(EncDecimal edecimal1, float edecimal2) => edecimal1.Value + (decimal)edecimal2; - public static decimal operator -(EncDecimal edecimal1, float edecimal2) => edecimal1.Value - (decimal)edecimal2; - public static decimal operator *(EncDecimal edecimal1, float edecimal2) => edecimal1.Value * (decimal)edecimal2; - public static decimal operator /(EncDecimal edecimal1, float edecimal2) => edecimal1.Value / (decimal)edecimal2; - public static decimal operator %(EncDecimal edecimal1, float edecimal2) => edecimal1.Value % (decimal)edecimal2; + public static EncDecimal operator +(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Decrypt + eint2.Decrypt); + public static EncDecimal operator -(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Decrypt - eint2.Decrypt); + public static EncDecimal operator *(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Decrypt * eint2.Decrypt); + public static EncDecimal operator /(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Decrypt / eint2.Decrypt); + public static EncDecimal operator %(EncDecimal eint1, EncDecimal eint2) => new EncDecimal(eint1.Decrypt % eint2.Decrypt); + + public static decimal operator +(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, long edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, long edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, long edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, long edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, long edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, uint edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, uint edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, uint edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, uint edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, uint edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, int edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, int edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, int edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, int edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, int edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, short edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, short edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, short edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, short edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, short edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, byte edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, byte edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, byte edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, byte edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, byte edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Decrypt + edecimal2; + public static decimal operator -(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Decrypt - edecimal2; + public static decimal operator *(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Decrypt * edecimal2; + public static decimal operator /(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Decrypt / edecimal2; + public static decimal operator %(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Decrypt % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, double edecimal2) => edecimal1.Decrypt + (decimal)edecimal2; + public static decimal operator -(EncDecimal edecimal1, double edecimal2) => edecimal1.Decrypt - (decimal)edecimal2; + public static decimal operator *(EncDecimal edecimal1, double edecimal2) => edecimal1.Decrypt * (decimal)edecimal2; + public static decimal operator /(EncDecimal edecimal1, double edecimal2) => edecimal1.Decrypt / (decimal)edecimal2; + public static decimal operator %(EncDecimal edecimal1, double edecimal2) => edecimal1.Decrypt % (decimal)edecimal2; + + public static decimal operator +(EncDecimal edecimal1, float edecimal2) => edecimal1.Decrypt + (decimal)edecimal2; + public static decimal operator -(EncDecimal edecimal1, float edecimal2) => edecimal1.Decrypt - (decimal)edecimal2; + public static decimal operator *(EncDecimal edecimal1, float edecimal2) => edecimal1.Decrypt * (decimal)edecimal2; + public static decimal operator /(EncDecimal edecimal1, float edecimal2) => edecimal1.Decrypt / (decimal)edecimal2; + public static decimal operator %(EncDecimal edecimal1, float edecimal2) => edecimal1.Decrypt % (decimal)edecimal2; /// == != < > - public static bool operator ==(EncDecimal eint1, EncDecimal eint2) => eint1.Value == eint2.Value; - public static bool operator !=(EncDecimal eint1, EncDecimal eint2) => eint1.Value != eint2.Value; - public static bool operator <(EncDecimal eint1, EncDecimal eint2) => eint1.Value < eint2.Value; - public static bool operator >(EncDecimal eint1, EncDecimal eint2) => eint1.Value > eint2.Value; - - public static bool operator ==(EncDecimal eint1, ulong eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, ulong eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, ulong eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, ulong eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, long eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, long eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, long eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, long eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, uint eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, uint eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, uint eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, uint eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, int eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, int eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, int eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, int eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, ushort eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, ushort eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, ushort eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, ushort eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, short eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, short eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, short eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, short eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, byte eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, byte eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, byte eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, byte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, sbyte eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, sbyte eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, sbyte eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, sbyte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, decimal eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, decimal eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, decimal eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, decimal eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDecimal eint1, double eint2) => eint1.Value == (decimal)eint2; - public static bool operator !=(EncDecimal eint1, double eint2) => eint1.Value != (decimal)eint2; - public static bool operator >(EncDecimal eint1, double eint2) => eint1.Value > (decimal)eint2; - public static bool operator <(EncDecimal eint1, double eint2) => eint1.Value < (decimal)eint2; - - public static bool operator ==(EncDecimal eint1, float eint2) => eint1.Value == (decimal)eint2; - public static bool operator !=(EncDecimal eint1, float eint2) => eint1.Value != (decimal)eint2; - public static bool operator >(EncDecimal eint1, float eint2) => eint1.Value > (decimal)eint2; - public static bool operator <(EncDecimal eint1, float eint2) => eint1.Value < (decimal)eint2; + public static bool operator ==(EncDecimal eint1, EncDecimal eint2) => eint1.Decrypt == eint2.Decrypt; + public static bool operator !=(EncDecimal eint1, EncDecimal eint2) => eint1.Decrypt != eint2.Decrypt; + public static bool operator <(EncDecimal eint1, EncDecimal eint2) => eint1.Decrypt < eint2.Decrypt; + public static bool operator >(EncDecimal eint1, EncDecimal eint2) => eint1.Decrypt > eint2.Decrypt; + + public static bool operator ==(EncDecimal eint1, ulong eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, ulong eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, ulong eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, ulong eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, long eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, long eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, long eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, long eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, uint eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, uint eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, uint eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, uint eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, int eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, int eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, int eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, int eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, ushort eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, ushort eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, ushort eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, ushort eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, short eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, short eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, short eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, short eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, byte eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, byte eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, byte eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, byte eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, sbyte eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, sbyte eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, sbyte eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, sbyte eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, decimal eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDecimal eint1, decimal eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDecimal eint1, decimal eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDecimal eint1, decimal eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDecimal eint1, double eint2) => eint1.Decrypt == (decimal)eint2; + public static bool operator !=(EncDecimal eint1, double eint2) => eint1.Decrypt != (decimal)eint2; + public static bool operator >(EncDecimal eint1, double eint2) => eint1.Decrypt > (decimal)eint2; + public static bool operator <(EncDecimal eint1, double eint2) => eint1.Decrypt < (decimal)eint2; + + public static bool operator ==(EncDecimal eint1, float eint2) => eint1.Decrypt == (decimal)eint2; + public static bool operator !=(EncDecimal eint1, float eint2) => eint1.Decrypt != (decimal)eint2; + public static bool operator >(EncDecimal eint1, float eint2) => eint1.Decrypt > (decimal)eint2; + public static bool operator <(EncDecimal eint1, float eint2) => eint1.Decrypt < (decimal)eint2; /// assign @@ -240,17 +237,17 @@ private decimal Decrypt() public static implicit operator EncDecimal(byte value) => new EncDecimal(value); public static implicit operator EncDecimal(sbyte value) => new EncDecimal(value); - public static implicit operator decimal(EncDecimal eint1) => eint1.Value; - public static explicit operator double(EncDecimal eint1) => (double)eint1.Value; - public static explicit operator float(EncDecimal eint1) => (float)eint1.Value; - public static explicit operator ulong(EncDecimal eint1) => (ulong)eint1.Value; - public static explicit operator long(EncDecimal eint1) => (long)eint1.Value; - public static explicit operator uint(EncDecimal eint1) => (uint)eint1.Value; - public static explicit operator int(EncDecimal eint1) => (int)eint1.Value; - public static explicit operator ushort(EncDecimal eint1) => (ushort)eint1.Value; - public static explicit operator short(EncDecimal eint1) => (short)eint1.Value; - public static explicit operator byte(EncDecimal eint1) => (byte)eint1.Value; - public static explicit operator sbyte(EncDecimal eint1) => (sbyte)eint1.Value; + public static implicit operator decimal(EncDecimal eint1) => eint1.Decrypt; + public static explicit operator double(EncDecimal eint1) => (double)eint1.Decrypt; + public static explicit operator float(EncDecimal eint1) => (float)eint1.Decrypt; + public static explicit operator ulong(EncDecimal eint1) => (ulong)eint1.Decrypt; + public static explicit operator long(EncDecimal eint1) => (long)eint1.Decrypt; + public static explicit operator uint(EncDecimal eint1) => (uint)eint1.Decrypt; + public static explicit operator int(EncDecimal eint1) => (int)eint1.Decrypt; + public static explicit operator ushort(EncDecimal eint1) => (ushort)eint1.Decrypt; + public static explicit operator short(EncDecimal eint1) => (short)eint1.Decrypt; + public static explicit operator byte(EncDecimal eint1) => (byte)eint1.Decrypt; + public static explicit operator sbyte(EncDecimal eint1) => (sbyte)eint1.Decrypt; #endregion } \ No newline at end of file diff --git a/EncTypes/EncDouble.cs b/EncTypes/EncDouble.cs index 0561a02..d7e12d7 100644 --- a/EncTypes/EncDouble.cs +++ b/EncTypes/EncDouble.cs @@ -12,16 +12,23 @@ public struct EncDouble #region Variables And Properties - // The encryption values private readonly byte[] encryptionKeys; // The encrypted value stored in memory private readonly byte[] encryptedValue; - // The decrypted value - public double Value + // Takes an encrypted value and returns it decrypted + private double Decrypt { - get => Decrypt(); + get + { + var valueBytes = new byte[8]; + for (int i = 0; i < 8; i++) + { + valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); + } + return BitConverter.ToDouble(valueBytes); + } } public static Double Epsilon { get => Double.Epsilon; } @@ -56,161 +63,150 @@ private static byte[] Encrypt(double value, byte[] keys) return valueBytes; } - // Takes an encrypted value and returns it decrypted - private double Decrypt() - { - var valueBytes = new byte[8]; - for (int i = 0; i < 8; i++) - { - valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); - } - return BitConverter.ToDouble(valueBytes); - } - // Overrides - public int CompareTo(object value) => Value.CompareTo(value); - public int CompareTo(Double value) => Value.CompareTo(value); - public bool Equals(Double obj) => Value.Equals(obj); - public override bool Equals(object obj) => Value.Equals(obj); - public override int GetHashCode() => Value.GetHashCode(); - public TypeCode GetTypeCode() => Value.GetTypeCode(); - public override string ToString() => Value.ToString(); - public string ToString(IFormatProvider provider) => Value.ToString(provider); - public string ToString(string format) => Value.ToString(format); - public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + public int CompareTo(object value) => Decrypt.CompareTo(value); + public int CompareTo(Double value) => Decrypt.CompareTo(value); + public bool Equals(Double obj) => Decrypt.Equals(obj); + public override bool Equals(object obj) => Decrypt.Equals(obj); + public override int GetHashCode() => Decrypt.GetHashCode(); + public TypeCode GetTypeCode() => Decrypt.GetTypeCode(); + public override string ToString() => Decrypt.ToString(); + public string ToString(IFormatProvider provider) => Decrypt.ToString(provider); + public string ToString(string format) => Decrypt.ToString(format); + public string ToString(string format, IFormatProvider provider) => Decrypt.ToString(format, provider); #endregion #region Operators Overloading /// + - * / % - public static EncDouble operator +(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Value + eint2.Value); - public static EncDouble operator -(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Value - eint2.Value); - public static EncDouble operator *(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Value * eint2.Value); - public static EncDouble operator /(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Value / eint2.Value); - public static EncDouble operator %(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Value % eint2.Value); - - public static double operator +(EncDouble edouble1, ulong edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, ulong edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, ulong edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, ulong edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, ulong edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, long edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, long edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, long edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, long edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, long edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, uint edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, uint edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, uint edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, uint edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, uint edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, int edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, int edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, int edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, int edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, int edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, ushort edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, ushort edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, ushort edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, ushort edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, ushort edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, short edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, short edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, short edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, short edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, short edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, byte edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, byte edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, byte edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, byte edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, byte edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, sbyte edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, sbyte edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, sbyte edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, sbyte edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, sbyte edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, double edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, double edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, double edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, double edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, double edouble2) => edouble1.Value % edouble2; - - public static double operator +(EncDouble edouble1, float edouble2) => edouble1.Value + edouble2; - public static double operator -(EncDouble edouble1, float edouble2) => edouble1.Value - edouble2; - public static double operator *(EncDouble edouble1, float edouble2) => edouble1.Value * edouble2; - public static double operator /(EncDouble edouble1, float edouble2) => edouble1.Value / edouble2; - public static double operator %(EncDouble edouble1, float edouble2) => edouble1.Value % edouble2; + public static EncDouble operator +(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Decrypt + eint2.Decrypt); + public static EncDouble operator -(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Decrypt - eint2.Decrypt); + public static EncDouble operator *(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Decrypt * eint2.Decrypt); + public static EncDouble operator /(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Decrypt / eint2.Decrypt); + public static EncDouble operator %(EncDouble eint1, EncDouble eint2) => new EncDouble(eint1.Decrypt % eint2.Decrypt); + + public static double operator +(EncDouble edouble1, ulong edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, ulong edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, ulong edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, ulong edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, ulong edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, long edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, long edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, long edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, long edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, long edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, uint edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, uint edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, uint edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, uint edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, uint edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, int edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, int edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, int edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, int edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, int edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, ushort edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, ushort edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, ushort edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, ushort edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, ushort edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, short edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, short edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, short edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, short edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, short edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, byte edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, byte edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, byte edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, byte edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, byte edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, sbyte edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, sbyte edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, sbyte edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, sbyte edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, sbyte edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, double edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, double edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, double edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, double edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, double edouble2) => edouble1.Decrypt % edouble2; + + public static double operator +(EncDouble edouble1, float edouble2) => edouble1.Decrypt + edouble2; + public static double operator -(EncDouble edouble1, float edouble2) => edouble1.Decrypt - edouble2; + public static double operator *(EncDouble edouble1, float edouble2) => edouble1.Decrypt * edouble2; + public static double operator /(EncDouble edouble1, float edouble2) => edouble1.Decrypt / edouble2; + public static double operator %(EncDouble edouble1, float edouble2) => edouble1.Decrypt % edouble2; /// == != < > - public static bool operator ==(EncDouble eint1, EncDouble eint2) => eint1.Value == eint2.Value; - public static bool operator !=(EncDouble eint1, EncDouble eint2) => eint1.Value != eint2.Value; - public static bool operator <(EncDouble eint1, EncDouble eint2) => eint1.Value < eint2.Value; - public static bool operator >(EncDouble eint1, EncDouble eint2) => eint1.Value > eint2.Value; - - public static bool operator ==(EncDouble eint1, ulong eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, ulong eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, ulong eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, ulong eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, long eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, long eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, long eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, long eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, uint eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, uint eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, uint eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, uint eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, int eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, int eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, int eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, int eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, ushort eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, ushort eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, ushort eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, ushort eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, short eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, short eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, short eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, short eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, byte eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, byte eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, byte eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, byte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, sbyte eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, sbyte eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, sbyte eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, sbyte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, decimal eint2) => (decimal)eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, decimal eint2) => (decimal)eint1.Value != eint2; - public static bool operator >(EncDouble eint1, decimal eint2) => (decimal)eint1.Value > eint2; - public static bool operator <(EncDouble eint1, decimal eint2) => (decimal)eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, double eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, double eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, double eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, double eint2) => eint1.Value < eint2; - - public static bool operator ==(EncDouble eint1, float eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, float eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, float eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, float eint2) => eint1.Value < eint2; + public static bool operator ==(EncDouble eint1, EncDouble eint2) => eint1.Decrypt == eint2.Decrypt; + public static bool operator !=(EncDouble eint1, EncDouble eint2) => eint1.Decrypt != eint2.Decrypt; + public static bool operator <(EncDouble eint1, EncDouble eint2) => eint1.Decrypt < eint2.Decrypt; + public static bool operator >(EncDouble eint1, EncDouble eint2) => eint1.Decrypt > eint2.Decrypt; + + public static bool operator ==(EncDouble eint1, ulong eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, ulong eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, ulong eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, ulong eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, long eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, long eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, long eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, long eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, uint eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, uint eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, uint eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, uint eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, int eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, int eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, int eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, int eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, ushort eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, ushort eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, ushort eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, ushort eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, short eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, short eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, short eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, short eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, byte eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, byte eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, byte eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, byte eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, sbyte eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, sbyte eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, sbyte eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, sbyte eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, decimal eint2) => (decimal)eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, decimal eint2) => (decimal)eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, decimal eint2) => (decimal)eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, decimal eint2) => (decimal)eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, double eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, double eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, double eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, double eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncDouble eint1, float eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncDouble eint1, float eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncDouble eint1, float eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncDouble eint1, float eint2) => eint1.Decrypt < eint2; /// assign public static implicit operator EncDouble(ulong value) => new EncDouble(value); @@ -225,17 +221,17 @@ private double Decrypt() public static implicit operator EncDouble(double value) => new EncDouble(value); public static implicit operator EncDouble(float value) => new EncDouble(value); - public static explicit operator decimal(EncDouble eint1) => (decimal)eint1.Value; - public static implicit operator double(EncDouble eint1) => eint1.Value; - public static explicit operator float(EncDouble eint1) => (float)eint1.Value; - public static explicit operator ulong(EncDouble eint1) => (ulong)eint1.Value; - public static explicit operator long(EncDouble eint1) => (long)eint1.Value; - public static explicit operator uint(EncDouble eint1) => (uint)eint1.Value; - public static explicit operator int(EncDouble eint1) => (int)eint1.Value; - public static explicit operator ushort(EncDouble eint1) => (ushort)eint1.Value; - public static explicit operator short(EncDouble eint1) => (short)eint1.Value; - public static explicit operator byte(EncDouble eint1) => (byte)eint1.Value; - public static explicit operator sbyte(EncDouble eint1) => (sbyte)eint1.Value; + public static explicit operator decimal(EncDouble eint1) => (decimal)eint1.Decrypt; + public static implicit operator double(EncDouble eint1) => eint1.Decrypt; + public static explicit operator float(EncDouble eint1) => (float)eint1.Decrypt; + public static explicit operator ulong(EncDouble eint1) => (ulong)eint1.Decrypt; + public static explicit operator long(EncDouble eint1) => (long)eint1.Decrypt; + public static explicit operator uint(EncDouble eint1) => (uint)eint1.Decrypt; + public static explicit operator int(EncDouble eint1) => (int)eint1.Decrypt; + public static explicit operator ushort(EncDouble eint1) => (ushort)eint1.Decrypt; + public static explicit operator short(EncDouble eint1) => (short)eint1.Decrypt; + public static explicit operator byte(EncDouble eint1) => (byte)eint1.Decrypt; + public static explicit operator sbyte(EncDouble eint1) => (sbyte)eint1.Decrypt; #endregion } \ No newline at end of file diff --git a/EncTypes/EncFloat.cs b/EncTypes/EncFloat.cs index 23778c7..b126d85 100644 --- a/EncTypes/EncFloat.cs +++ b/EncTypes/EncFloat.cs @@ -2,27 +2,33 @@ public struct EncFloat { - /// A struct for storing a Single (float) while efficiently keeping it encrypted in the memory. + /// A struct for storing a Single (float) while efficiently keeping it encrypted in the memory /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted /// The encryption will happen in the background without you worrying about it - /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } - /// Every time the value changes, the encryption keys change too. And it works exactly as an float. + /// In the memory it is saved as a an array of weird bytes that are affected by random values { encryptionKeys array } + /// Every time the value changes, the encryption keys change too. And it works exactly as an float (Single) /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties - // The encryption values - private readonly double encryptionKey1; - private readonly double encryptionKey2; + private readonly byte[] encryptionKeys; // The encrypted value stored in memory - private readonly double encryptedValue; + private readonly byte[] encryptedValue; - // The decrypted value - private float Value + // Takes an encrypted value and returns it decrypted + private float Decrypt { - get => (float)Decrypt(); + get + { + var valueBytes = new byte[4]; + for (int i = 0; i < 4; i++) + { + valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); + } + return BitConverter.ToSingle(valueBytes); + } } public static float Epsilon { get => Single.Epsilon; } @@ -35,160 +41,166 @@ private float Value #endregion #region Methods And Constructors + private EncFloat(float value) { - encryptionKey1 = random.NextDouble() * 0.001; - encryptionKey2 = random.NextDouble() * 100; - encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + encryptionKeys = new byte[4]; + encryptedValue = Encrypt(value, encryptionKeys); } // encryption key generator static private Random random = new Random(); // Takes a given value and returns it encrypted - private static double Encrypt(double value, double k1, double k2) => (value * k1) * k2; - - // Takes an encrypted value and returns it decrypted - private double Decrypt() => (encryptedValue / encryptionKey2) / encryptionKey1; + private static byte[] Encrypt(float value, byte[] keys) + { + random.NextBytes(keys); + var valueBytes = BitConverter.GetBytes(value); + for (int i = 0; i < 4; i++) + { + valueBytes[i] ^= keys[i]; + } + return valueBytes; + } // Single methods - public int CompareTo(Single value) => Value.CompareTo(value); - public int CompareTo(object value) => Value.CompareTo(value); - public override bool Equals(object obj) => Value.Equals(obj); - public bool Equals(Single obj) => Value.Equals(obj); - public override int GetHashCode() => Value.GetHashCode(); - public TypeCode GetTypeCode() => Value.GetTypeCode(); - public override string ToString() => Value.ToString(); - public string ToString(IFormatProvider provider) => Value.ToString(provider); - public string ToString(string format) => Value.ToString(format); - public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + public int CompareTo(Single value) => Decrypt.CompareTo(value); + public int CompareTo(object value) => Decrypt.CompareTo(value); + public override bool Equals(object obj) => Decrypt.Equals(obj); + public bool Equals(Single obj) => Decrypt.Equals(obj); + public override int GetHashCode() => Decrypt.GetHashCode(); + public TypeCode GetTypeCode() => Decrypt.GetTypeCode(); + public override string ToString() => Decrypt.ToString(); + public string ToString(IFormatProvider provider) => Decrypt.ToString(provider); + public string ToString(string format) => Decrypt.ToString(format); + public string ToString(string format, IFormatProvider provider) => Decrypt.ToString(format, provider); #endregion #region Operators Overloading /// + - * / % - public static EncFloat operator +(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Value + eint2.Value); - public static EncFloat operator -(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Value - eint2.Value); - public static EncFloat operator *(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Value * eint2.Value); - public static EncFloat operator /(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Value / eint2.Value); - public static EncFloat operator %(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Value % eint2.Value); - - public static float operator +(EncFloat efloat1, ulong efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, ulong efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, ulong efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, ulong efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, ulong efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, long efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, long efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, long efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, long efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, long efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, uint efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, uint efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, uint efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, uint efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, uint efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, int efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, int efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, int efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, int efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, int efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, ushort efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, ushort efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, ushort efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, ushort efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, ushort efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, short efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, short efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, short efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, short efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, short efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, byte efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, byte efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, byte efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, byte efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, byte efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, sbyte efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, sbyte efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, sbyte efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, sbyte efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, sbyte efloat2) => efloat1.Value % efloat2; - - public static float operator +(EncFloat efloat1, float efloat2) => efloat1.Value + efloat2; - public static float operator -(EncFloat efloat1, float efloat2) => efloat1.Value - efloat2; - public static float operator *(EncFloat efloat1, float efloat2) => efloat1.Value * efloat2; - public static float operator /(EncFloat efloat1, float efloat2) => efloat1.Value / efloat2; - public static float operator %(EncFloat efloat1, float efloat2) => efloat1.Value % efloat2; + public static EncFloat operator +(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Decrypt + eint2.Decrypt); + public static EncFloat operator -(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Decrypt - eint2.Decrypt); + public static EncFloat operator *(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Decrypt * eint2.Decrypt); + public static EncFloat operator /(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Decrypt / eint2.Decrypt); + public static EncFloat operator %(EncFloat eint1, EncFloat eint2) => new EncFloat(eint1.Decrypt % eint2.Decrypt); + + public static float operator +(EncFloat efloat1, ulong efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, ulong efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, ulong efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, ulong efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, ulong efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, long efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, long efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, long efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, long efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, long efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, uint efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, uint efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, uint efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, uint efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, uint efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, int efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, int efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, int efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, int efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, int efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, ushort efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, ushort efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, ushort efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, ushort efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, ushort efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, short efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, short efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, short efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, short efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, short efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, byte efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, byte efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, byte efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, byte efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, byte efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, sbyte efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, sbyte efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, sbyte efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, sbyte efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, sbyte efloat2) => efloat1.Decrypt % efloat2; + + public static float operator +(EncFloat efloat1, float efloat2) => efloat1.Decrypt + efloat2; + public static float operator -(EncFloat efloat1, float efloat2) => efloat1.Decrypt - efloat2; + public static float operator *(EncFloat efloat1, float efloat2) => efloat1.Decrypt * efloat2; + public static float operator /(EncFloat efloat1, float efloat2) => efloat1.Decrypt / efloat2; + public static float operator %(EncFloat efloat1, float efloat2) => efloat1.Decrypt % efloat2; /// == != < > - public static bool operator ==(EncFloat eint1, EncFloat eint2) => eint1.Value == eint2.Value; - public static bool operator !=(EncFloat eint1, EncFloat eint2) => eint1.Value != eint2.Value; - public static bool operator <(EncFloat eint1, EncFloat eint2) => eint1.Value < eint2.Value; - public static bool operator >(EncFloat eint1, EncFloat eint2) => eint1.Value > eint2.Value; - - public static bool operator ==(EncFloat eint1, ulong eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, ulong eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, ulong eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, ulong eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, long eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, long eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, long eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, long eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, uint eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, uint eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, uint eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, uint eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, int eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, int eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, int eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, int eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, ushort eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, ushort eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, ushort eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, ushort eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, short eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, short eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, short eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, short eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, byte eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, byte eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, byte eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, byte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, sbyte eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, sbyte eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, sbyte eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, sbyte eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, decimal eint2) => (decimal)eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, decimal eint2) => (decimal)eint1.Value != eint2; - public static bool operator >(EncFloat eint1, decimal eint2) => (decimal)eint1.Value > eint2; - public static bool operator <(EncFloat eint1, decimal eint2) => (decimal)eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, double eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, double eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, double eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, double eint2) => eint1.Value < eint2; - - public static bool operator ==(EncFloat eint1, float eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, float eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, float eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, float eint2) => eint1.Value < eint2; + public static bool operator ==(EncFloat eint1, EncFloat eint2) => eint1.Decrypt == eint2.Decrypt; + public static bool operator !=(EncFloat eint1, EncFloat eint2) => eint1.Decrypt != eint2.Decrypt; + public static bool operator <(EncFloat eint1, EncFloat eint2) => eint1.Decrypt < eint2.Decrypt; + public static bool operator >(EncFloat eint1, EncFloat eint2) => eint1.Decrypt > eint2.Decrypt; + + public static bool operator ==(EncFloat eint1, ulong eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, ulong eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, ulong eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, ulong eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, long eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, long eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, long eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, long eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, uint eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, uint eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, uint eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, uint eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, int eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, int eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, int eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, int eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, ushort eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, ushort eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, ushort eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, ushort eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, short eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, short eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, short eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, short eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, byte eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, byte eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, byte eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, byte eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, sbyte eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, sbyte eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, sbyte eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, sbyte eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, decimal eint2) => (decimal)eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, decimal eint2) => (decimal)eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, decimal eint2) => (decimal)eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, decimal eint2) => (decimal)eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, double eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, double eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, double eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, double eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncFloat eint1, float eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncFloat eint1, float eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncFloat eint1, float eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncFloat eint1, float eint2) => eint1.Decrypt < eint2; /// assign public static implicit operator EncFloat(ulong value) => new EncFloat(value); @@ -203,17 +215,17 @@ private EncFloat(float value) public static explicit operator EncFloat(double value) => new EncFloat((float)value); public static implicit operator EncFloat(float value) => new EncFloat(value); - public static explicit operator decimal(EncFloat eint1) => (decimal)eint1.Value; - public static implicit operator double(EncFloat eint1) => eint1.Value; - public static implicit operator float(EncFloat eint1) => eint1.Value; - public static explicit operator ulong(EncFloat eint1) => (ulong)eint1.Value; - public static explicit operator long(EncFloat eint1) => (long)eint1.Value; - public static explicit operator uint(EncFloat eint1) => (uint)eint1.Value; - public static explicit operator int(EncFloat eint1) => (int)eint1.Value; - public static explicit operator ushort(EncFloat eint1) => (ushort)eint1.Value; - public static explicit operator short(EncFloat eint1) => (short)eint1.Value; - public static explicit operator byte(EncFloat eint1) => (byte)eint1.Value; - public static explicit operator sbyte(EncFloat eint1) => (sbyte)eint1.Value; + public static explicit operator decimal(EncFloat eint1) => (decimal)eint1.Decrypt; + public static implicit operator double(EncFloat eint1) => eint1.Decrypt; + public static implicit operator float(EncFloat eint1) => eint1.Decrypt; + public static explicit operator ulong(EncFloat eint1) => (ulong)eint1.Decrypt; + public static explicit operator long(EncFloat eint1) => (long)eint1.Decrypt; + public static explicit operator uint(EncFloat eint1) => (uint)eint1.Decrypt; + public static explicit operator int(EncFloat eint1) => (int)eint1.Decrypt; + public static explicit operator ushort(EncFloat eint1) => (ushort)eint1.Decrypt; + public static explicit operator short(EncFloat eint1) => (short)eint1.Decrypt; + public static explicit operator byte(EncFloat eint1) => (byte)eint1.Decrypt; + public static explicit operator sbyte(EncFloat eint1) => (sbyte)eint1.Decrypt; #endregion } \ No newline at end of file diff --git a/EncTypes/EncInt.cs b/EncTypes/EncInt.cs index 4aa5dc8..9634cb5 100644 --- a/EncTypes/EncInt.cs +++ b/EncTypes/EncInt.cs @@ -5,24 +5,30 @@ public struct EncInt /// A struct for storing a 32-bit integer while efficiently keeping it encrypted in the memory /// Instead of encrypting and decrypting yourself, you can just use the encrypted type (EncType) of the variable you want to be encrypted /// The encryption will happen in the background without you worrying about it - /// In the memory it is saved as a weird floating-point number that is affected by random values { encryptionKey1 & encryptionKey2 } + /// In the memory it is saved as a an array of weird bytes that are affected by random values { encryptionKeys array } /// Every time the value changes, the encryption keys change too. And it works exactly as an int (Int32) /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties - // The encryption values - private readonly double encryptionKey1; - private readonly double encryptionKey2; + private readonly byte[] encryptionKeys; // The encrypted value stored in memory - private readonly double encryptedValue; + private readonly byte[] encryptedValue; - // The decrypted value - private int Value + // Takes an encrypted value and returns it decrypted + private int Decrypt { - get => (int)Decrypt(); + get + { + var valueBytes = new byte[4]; + for (int i = 0; i < 4; i++) + { + valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); + } + return BitConverter.ToInt32(valueBytes); + } } public static int MaxValue { get => Int32.MaxValue; } @@ -34,144 +40,149 @@ private int Value private EncInt(int value) { - encryptionKey1 = random.NextDouble() * 0.001; - encryptionKey2 = random.NextDouble() * 100; - encryptedValue = Encrypt(value, encryptionKey1, encryptionKey2); + encryptionKeys = new byte[4]; + encryptedValue = Encrypt(value, encryptionKeys); } // Encryption Key Generator static private Random random = new Random(); // Takes a given value and returns it encrypted - private static double Encrypt(double value, double k1, double k2) => (value * k1) * k2; - - // Takes an encrypted value and returns it decrypted - private double Decrypt() => ((encryptedValue / encryptionKey2) / encryptionKey1) + 0.5; + private static byte[] Encrypt(int value, byte[] keys) + { + random.NextBytes(keys); + var valueBytes = BitConverter.GetBytes(value); + for (int i = 0; i < 4; i++) + { + valueBytes[i] ^= keys[i]; + } + return valueBytes; + } // Int32 methods - public Int32 CompareTo(object value) => Value.CompareTo(value); - public Int32 CompareTo(Int32 value) => Value.CompareTo(value); - public bool Equals(Int32 obj) => Value.Equals(obj); - public override bool Equals(object obj) => Value.Equals(obj); - public override Int32 GetHashCode() => Value.GetHashCode(); - public TypeCode GetTypeCode() => Value.GetTypeCode(); - public override string ToString() => Value.ToString(); - public string ToString(IFormatProvider provider) => Value.ToString(provider); - public string ToString(string format) => Value.ToString(format); - public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + public Int32 CompareTo(object value) => Decrypt.CompareTo(value); + public Int32 CompareTo(Int32 value) => Decrypt.CompareTo(value); + public bool Equals(Int32 obj) => Decrypt.Equals(obj); + public override bool Equals(object obj) => Decrypt.Equals(obj); + public override Int32 GetHashCode() => Decrypt.GetHashCode(); + public TypeCode GetTypeCode() => Decrypt.GetTypeCode(); + public override string ToString() => Decrypt.ToString(); + public string ToString(IFormatProvider provider) => Decrypt.ToString(provider); + public string ToString(string format) => Decrypt.ToString(format); + public string ToString(string format, IFormatProvider provider) => Decrypt.ToString(format, provider); #endregion #region Operators Overloading /// & | ^ << >> - public static EncInt operator &(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value & eint2.Value); - public static EncInt operator |(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value | eint2.Value); - public static EncInt operator ^(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value ^ eint2.Value); + public static EncInt operator &(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt & eint2.Decrypt); + public static EncInt operator |(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt | eint2.Decrypt); + public static EncInt operator ^(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt ^ eint2.Decrypt); - public static int operator &(EncInt eint1, int eint2) => eint1.Value & eint2; - public static int operator |(EncInt eint1, int eint2) => eint1.Value | eint2; - public static int operator ^(EncInt eint1, int eint2) => eint1.Value ^ eint2; - public static int operator >>(EncInt eint1, int eint2) => eint1.Value >> eint2; - public static int operator <<(EncInt eint1, int eint2) => eint1.Value << eint2; + public static int operator &(EncInt eint1, int eint2) => eint1.Decrypt & eint2; + public static int operator |(EncInt eint1, int eint2) => eint1.Decrypt | eint2; + public static int operator ^(EncInt eint1, int eint2) => eint1.Decrypt ^ eint2; + public static int operator >>(EncInt eint1, int eint2) => eint1.Decrypt >> eint2; + public static int operator <<(EncInt eint1, int eint2) => eint1.Decrypt << eint2; /// + - * / % - public static EncInt operator +(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value + eint2.Value); - public static EncInt operator -(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value - eint2.Value); - public static EncInt operator *(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value * eint2.Value); - public static EncInt operator /(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value / eint2.Value); - public static EncInt operator %(EncInt eint1, EncInt eint2) => new EncInt(eint1.Value % eint2.Value); - - public static int operator +(EncInt eint1, int eint2) => eint1.Value + eint2; - public static int operator -(EncInt eint1, int eint2) => eint1.Value - eint2; - public static int operator *(EncInt eint1, int eint2) => eint1.Value * eint2; - public static int operator /(EncInt eint1, int eint2) => eint1.Value / eint2; - public static int operator %(EncInt eint1, int eint2) => eint1.Value % eint2; - - public static int operator +(EncInt eint1, ushort eint2) => eint1.Value + eint2; - public static int operator -(EncInt eint1, ushort eint2) => eint1.Value - eint2; - public static int operator *(EncInt eint1, ushort eint2) => eint1.Value * eint2; - public static int operator /(EncInt eint1, ushort eint2) => eint1.Value / eint2; - public static int operator %(EncInt eint1, ushort eint2) => eint1.Value % eint2; - - public static int operator +(EncInt eint1, short eint2) => eint1.Value + eint2; - public static int operator -(EncInt eint1, short eint2) => eint1.Value - eint2; - public static int operator *(EncInt eint1, short eint2) => eint1.Value * eint2; - public static int operator /(EncInt eint1, short eint2) => eint1.Value / eint2; - public static int operator %(EncInt eint1, short eint2) => eint1.Value % eint2; - - public static int operator +(EncInt eint1, byte eint2) => eint1.Value + eint2; - public static int operator -(EncInt eint1, byte eint2) => eint1.Value - eint2; - public static int operator *(EncInt eint1, byte eint2) => eint1.Value * eint2; - public static int operator /(EncInt eint1, byte eint2) => eint1.Value / eint2; - public static int operator %(EncInt eint1, byte eint2) => eint1.Value % eint2; - - public static int operator +(EncInt eint1, sbyte eint2) => eint1.Value + eint2; - public static int operator -(EncInt eint1, sbyte eint2) => eint1.Value - eint2; - public static int operator *(EncInt eint1, sbyte eint2) => eint1.Value * eint2; - public static int operator /(EncInt eint1, sbyte eint2) => eint1.Value / eint2; - public static int operator %(EncInt eint1, sbyte eint2) => eint1.Value % eint2; + public static EncInt operator +(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt + eint2.Decrypt); + public static EncInt operator -(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt - eint2.Decrypt); + public static EncInt operator *(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt * eint2.Decrypt); + public static EncInt operator /(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt / eint2.Decrypt); + public static EncInt operator %(EncInt eint1, EncInt eint2) => new EncInt(eint1.Decrypt % eint2.Decrypt); + + public static int operator +(EncInt eint1, int eint2) => eint1.Decrypt + eint2; + public static int operator -(EncInt eint1, int eint2) => eint1.Decrypt - eint2; + public static int operator *(EncInt eint1, int eint2) => eint1.Decrypt * eint2; + public static int operator /(EncInt eint1, int eint2) => eint1.Decrypt / eint2; + public static int operator %(EncInt eint1, int eint2) => eint1.Decrypt % eint2; + + public static int operator +(EncInt eint1, ushort eint2) => eint1.Decrypt + eint2; + public static int operator -(EncInt eint1, ushort eint2) => eint1.Decrypt - eint2; + public static int operator *(EncInt eint1, ushort eint2) => eint1.Decrypt * eint2; + public static int operator /(EncInt eint1, ushort eint2) => eint1.Decrypt / eint2; + public static int operator %(EncInt eint1, ushort eint2) => eint1.Decrypt % eint2; + + public static int operator +(EncInt eint1, short eint2) => eint1.Decrypt + eint2; + public static int operator -(EncInt eint1, short eint2) => eint1.Decrypt - eint2; + public static int operator *(EncInt eint1, short eint2) => eint1.Decrypt * eint2; + public static int operator /(EncInt eint1, short eint2) => eint1.Decrypt / eint2; + public static int operator %(EncInt eint1, short eint2) => eint1.Decrypt % eint2; + + public static int operator +(EncInt eint1, byte eint2) => eint1.Decrypt + eint2; + public static int operator -(EncInt eint1, byte eint2) => eint1.Decrypt - eint2; + public static int operator *(EncInt eint1, byte eint2) => eint1.Decrypt * eint2; + public static int operator /(EncInt eint1, byte eint2) => eint1.Decrypt / eint2; + public static int operator %(EncInt eint1, byte eint2) => eint1.Decrypt % eint2; + + public static int operator +(EncInt eint1, sbyte eint2) => eint1.Decrypt + eint2; + public static int operator -(EncInt eint1, sbyte eint2) => eint1.Decrypt - eint2; + public static int operator *(EncInt eint1, sbyte eint2) => eint1.Decrypt * eint2; + public static int operator /(EncInt eint1, sbyte eint2) => eint1.Decrypt / eint2; + public static int operator %(EncInt eint1, sbyte eint2) => eint1.Decrypt % eint2; /// == != < > - public static bool operator ==(EncInt eint1, EncInt eint2) => eint1.Value == eint2.Value; - public static bool operator !=(EncInt eint1, EncInt eint2) => eint1.Value != eint2.Value; - public static bool operator <(EncInt eint1, EncInt eint2) => eint1.Value < eint2.Value; - public static bool operator >(EncInt eint1, EncInt eint2) => eint1.Value > eint2.Value; - - public static bool operator ==(EncInt eint1, ulong eint2) => (ulong)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, ulong eint2) => (ulong)eint1.Value != eint2; - public static bool operator >(EncInt eint1, ulong eint2) => (ulong)eint1.Value > eint2; - public static bool operator <(EncInt eint1, ulong eint2) => (ulong)eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, long eint2) => eint1.Value == eint2; - public static bool operator !=(EncInt eint1, long eint2) => eint1.Value != eint2; - public static bool operator >(EncInt eint1, long eint2) => eint1.Value > eint2; - public static bool operator <(EncInt eint1, long eint2) => eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, uint eint2) => (uint)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, uint eint2) => (uint)eint1.Value != eint2; - public static bool operator >(EncInt eint1, uint eint2) => (uint)eint1.Value > eint2; - public static bool operator <(EncInt eint1, uint eint2) => (uint)eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, int eint2) => eint1.Value == eint2; - public static bool operator !=(EncInt eint1, int eint2) => eint1.Value != eint2; - public static bool operator >(EncInt eint1, int eint2) => eint1.Value > eint2; - public static bool operator <(EncInt eint1, int eint2) => eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, ushort eint2) => (ushort)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, ushort eint2) => (ushort)eint1.Value != eint2; - public static bool operator >(EncInt eint1, ushort eint2) => (ushort)eint1.Value > eint2; - public static bool operator <(EncInt eint1, ushort eint2) => (ushort)eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, short eint2) => (short)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, short eint2) => (short)eint1.Value != eint2; - public static bool operator >(EncInt eint1, short eint2) => (short)eint1.Value > eint2; - public static bool operator <(EncInt eint1, short eint2) => (short)eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, byte eint2) => (byte)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, byte eint2) => (byte)eint1.Value != eint2; - public static bool operator >(EncInt eint1, byte eint2) => (byte)eint1.Value > eint2; - public static bool operator <(EncInt eint1, byte eint2) => (byte)eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value != eint2; - public static bool operator >(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value > eint2; - public static bool operator <(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, decimal eint2) => eint1.Value == eint2; - public static bool operator !=(EncInt eint1, decimal eint2) => eint1.Value != eint2; - public static bool operator >(EncInt eint1, decimal eint2) => eint1.Value > eint2; - public static bool operator <(EncInt eint1, decimal eint2) => eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, double eint2) => eint1.Value == eint2; - public static bool operator !=(EncInt eint1, double eint2) => eint1.Value != eint2; - public static bool operator >(EncInt eint1, double eint2) => eint1.Value > eint2; - public static bool operator <(EncInt eint1, double eint2) => eint1.Value < eint2; - - public static bool operator ==(EncInt eint1, float eint2) => eint1.Value == eint2; - public static bool operator !=(EncInt eint1, float eint2) => eint1.Value != eint2; - public static bool operator >(EncInt eint1, float eint2) => eint1.Value > eint2; - public static bool operator <(EncInt eint1, float eint2) => eint1.Value < eint2; + public static bool operator ==(EncInt eint1, EncInt eint2) => eint1.Decrypt == eint2.Decrypt; + public static bool operator !=(EncInt eint1, EncInt eint2) => eint1.Decrypt != eint2.Decrypt; + public static bool operator <(EncInt eint1, EncInt eint2) => eint1.Decrypt < eint2.Decrypt; + public static bool operator >(EncInt eint1, EncInt eint2) => eint1.Decrypt > eint2.Decrypt; + + public static bool operator ==(EncInt eint1, ulong eint2) => (ulong)eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, ulong eint2) => (ulong)eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, ulong eint2) => (ulong)eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, ulong eint2) => (ulong)eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, long eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, long eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, long eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, long eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, uint eint2) => (uint)eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, uint eint2) => (uint)eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, uint eint2) => (uint)eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, uint eint2) => (uint)eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, int eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, int eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, int eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, int eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, ushort eint2) => (ushort)eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, ushort eint2) => (ushort)eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, ushort eint2) => (ushort)eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, ushort eint2) => (ushort)eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, short eint2) => (short)eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, short eint2) => (short)eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, short eint2) => (short)eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, short eint2) => (short)eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, byte eint2) => (byte)eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, byte eint2) => (byte)eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, byte eint2) => (byte)eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, byte eint2) => (byte)eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, sbyte eint2) => (sbyte)eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, sbyte eint2) => (sbyte)eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, sbyte eint2) => (sbyte)eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, sbyte eint2) => (sbyte)eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, decimal eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, decimal eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, decimal eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, decimal eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, double eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, double eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, double eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, double eint2) => eint1.Decrypt < eint2; + + public static bool operator ==(EncInt eint1, float eint2) => eint1.Decrypt == eint2; + public static bool operator !=(EncInt eint1, float eint2) => eint1.Decrypt != eint2; + public static bool operator >(EncInt eint1, float eint2) => eint1.Decrypt > eint2; + public static bool operator <(EncInt eint1, float eint2) => eint1.Decrypt < eint2; /// assign public static explicit operator EncInt(ulong value) => new EncInt((int)value); @@ -186,17 +197,17 @@ private EncInt(int value) public static explicit operator EncInt(double value) => new EncInt((int)value); public static explicit operator EncInt(float value) => new EncInt((int)value); - public static explicit operator ulong(EncInt eint1) => (ulong)eint1.Value; - public static implicit operator long(EncInt eint1) => eint1.Value; - public static explicit operator uint(EncInt eint1) => (uint)eint1.Value; - public static implicit operator int(EncInt eint1) => eint1.Value; - public static explicit operator ushort(EncInt eint1) => (ushort)eint1.Value; - public static explicit operator short(EncInt eint1) => (short)eint1.Value; - public static explicit operator byte(EncInt eint1) => (byte)eint1.Value; - public static explicit operator sbyte(EncInt eint1) => (sbyte)eint1.Value; - public static implicit operator decimal(EncInt eint1) => eint1.Value; - public static implicit operator double(EncInt eint1) => eint1.Value; - public static implicit operator float(EncInt eint1) => eint1.Value; + public static explicit operator ulong(EncInt eint1) => (ulong)eint1.Decrypt; + public static implicit operator long(EncInt eint1) => eint1.Decrypt; + public static explicit operator uint(EncInt eint1) => (uint)eint1.Decrypt; + public static implicit operator int(EncInt eint1) => eint1.Decrypt; + public static explicit operator ushort(EncInt eint1) => (ushort)eint1.Decrypt; + public static explicit operator short(EncInt eint1) => (short)eint1.Decrypt; + public static explicit operator byte(EncInt eint1) => (byte)eint1.Decrypt; + public static explicit operator sbyte(EncInt eint1) => (sbyte)eint1.Decrypt; + public static implicit operator decimal(EncInt eint1) => eint1.Decrypt; + public static implicit operator double(EncInt eint1) => eint1.Decrypt; + public static implicit operator float(EncInt eint1) => eint1.Decrypt; #endregion } \ No newline at end of file diff --git a/EncTypes/EncLong.cs b/EncTypes/EncLong.cs index 352edbd..d2d1795 100644 --- a/EncTypes/EncLong.cs +++ b/EncTypes/EncLong.cs @@ -17,10 +17,18 @@ public struct EncLong // The encrypted value stored in memory private readonly byte[] encryptedValue; - // The decrypted value - private long Value + // Takes an encrypted value and returns it decrypted + private long Decrypt { - get => Decrypt(); + get + { + var valueBytes = new byte[8]; + for (int i = 0; i < 8; i++) + { + valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); + } + return BitConverter.ToInt64(valueBytes); + } } public static long MaxValue { get => Int64.MaxValue; } @@ -33,7 +41,6 @@ private long Value private EncLong(long value) { encryptionKeys = new byte[8]; - random.NextBytes(encryptionKeys); encryptedValue = Encrypt(value, encryptionKeys); } @@ -43,6 +50,7 @@ private EncLong(long value) // Takes a given value and returns it encrypted private static byte[] Encrypt(long value, byte[] keys) { + random.NextBytes(keys); var valueBytes = BitConverter.GetBytes(value); for (int i = 0; i < 8; i++) { @@ -51,133 +59,122 @@ private static byte[] Encrypt(long value, byte[] keys) return valueBytes; } - // Takes an encrypted value and returns it decrypted - private long Decrypt() - { - var valueBytes = new byte[8]; - for (int i = 0; i < 8; i++) - { - valueBytes[i] = (byte)(encryptedValue[i] ^ encryptionKeys[i]); - } - return BitConverter.ToInt64(valueBytes); - } - // Int64 methods - public int CompareTo(object value) => Value.CompareTo(value); - public int CompareTo(long value) => Value.CompareTo(value); - public bool Equals(long obj) => Value.Equals(obj); - public override bool Equals(object obj) => Value.Equals(obj); - public override int GetHashCode() => Value.GetHashCode(); - public TypeCode GetTypeCode() => Value.GetTypeCode(); - public override string ToString() => Value.ToString(); - public string ToString(IFormatProvider provider) => Value.ToString(provider); - public string ToString(string format) => Value.ToString(format); - public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); + public int CompareTo(object value) => Decrypt.CompareTo(value); + public int CompareTo(long value) => Decrypt.CompareTo(value); + public bool Equals(long obj) => Decrypt.Equals(obj); + public override bool Equals(object obj) => Decrypt.Equals(obj); + public override int GetHashCode() => Decrypt.GetHashCode(); + public TypeCode GetTypeCode() => Decrypt.GetTypeCode(); + public override string ToString() => Decrypt.ToString(); + public string ToString(IFormatProvider provider) => Decrypt.ToString(provider); + public string ToString(string format) => Decrypt.ToString(format); + public string ToString(string format, IFormatProvider provider) => Decrypt.ToString(format, provider); #endregion #region Operators Overloading /// & | ^ - public static EncLong operator &(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value & elong2.Value); - public static EncLong operator |(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value | elong2.Value); - public static EncLong operator ^(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value ^ elong2.Value); + public static EncLong operator &(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt & elong2.Decrypt); + public static EncLong operator |(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt | elong2.Decrypt); + public static EncLong operator ^(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt ^ elong2.Decrypt); - public static long operator &(EncLong elong1, long elong2) => elong1.Value & elong2; - public static long operator |(EncLong elong1, long elong2) => elong1.Value | elong2; - public static long operator ^(EncLong elong1, long elong2) => elong1.Value ^ elong2; + public static long operator &(EncLong elong1, long elong2) => elong1.Decrypt & elong2; + public static long operator |(EncLong elong1, long elong2) => elong1.Decrypt | elong2; + public static long operator ^(EncLong elong1, long elong2) => elong1.Decrypt ^ elong2; /// + - * / % - public static EncLong operator +(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value + elong2.Value); - public static EncLong operator -(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value - elong2.Value); - public static EncLong operator *(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value * elong2.Value); - public static EncLong operator /(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value / elong2.Value); - public static EncLong operator %(EncLong elong1, EncLong elong2) => new EncLong(elong1.Value % elong2.Value); - - public static long operator +(EncLong elong1, long elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, long elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, long elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, long elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, long elong2) => elong1.Value % elong2; - - public static long operator +(EncLong elong1, int elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, int elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, int elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, int elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, int elong2) => elong1.Value % elong2; - - public static long operator +(EncLong elong1, short elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, short elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, short elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, short elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, short elong2) => elong1.Value % elong2; - - public static long operator +(EncLong elong1, ushort elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, ushort elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, ushort elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, ushort elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, ushort elong2) => elong1.Value % elong2; - - public static long operator +(EncLong elong1, uint elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, uint elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, uint elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, uint elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, uint elong2) => elong1.Value % elong2; - - public static long operator +(EncLong elong1, byte elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, byte elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, byte elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, byte elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, byte elong2) => elong1.Value % elong2; - - public static long operator +(EncLong elong1, sbyte elong2) => elong1.Value + elong2; - public static long operator -(EncLong elong1, sbyte elong2) => elong1.Value - elong2; - public static long operator *(EncLong elong1, sbyte elong2) => elong1.Value * elong2; - public static long operator /(EncLong elong1, sbyte elong2) => elong1.Value / elong2; - public static long operator %(EncLong elong1, sbyte elong2) => elong1.Value % elong2; + public static EncLong operator +(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt + elong2.Decrypt); + public static EncLong operator -(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt - elong2.Decrypt); + public static EncLong operator *(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt * elong2.Decrypt); + public static EncLong operator /(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt / elong2.Decrypt); + public static EncLong operator %(EncLong elong1, EncLong elong2) => new EncLong(elong1.Decrypt % elong2.Decrypt); + + public static long operator +(EncLong elong1, long elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, long elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, long elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, long elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, long elong2) => elong1.Decrypt % elong2; + + public static long operator +(EncLong elong1, int elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, int elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, int elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, int elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, int elong2) => elong1.Decrypt % elong2; + + public static long operator +(EncLong elong1, short elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, short elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, short elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, short elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, short elong2) => elong1.Decrypt % elong2; + + public static long operator +(EncLong elong1, ushort elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, ushort elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, ushort elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, ushort elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, ushort elong2) => elong1.Decrypt % elong2; + + public static long operator +(EncLong elong1, uint elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, uint elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, uint elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, uint elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, uint elong2) => elong1.Decrypt % elong2; + + public static long operator +(EncLong elong1, byte elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, byte elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, byte elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, byte elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, byte elong2) => elong1.Decrypt % elong2; + + public static long operator +(EncLong elong1, sbyte elong2) => elong1.Decrypt + elong2; + public static long operator -(EncLong elong1, sbyte elong2) => elong1.Decrypt - elong2; + public static long operator *(EncLong elong1, sbyte elong2) => elong1.Decrypt * elong2; + public static long operator /(EncLong elong1, sbyte elong2) => elong1.Decrypt / elong2; + public static long operator %(EncLong elong1, sbyte elong2) => elong1.Decrypt % elong2; /// == != < > /// - public static bool operator ==(EncLong elong1, byte elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, byte elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, byte elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, byte elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, sbyte elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, sbyte elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, sbyte elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, sbyte elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, short elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, short elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, short elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, short elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, ushort elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, ushort elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, ushort elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, ushort elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, uint elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, uint elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, uint elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, uint elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, int elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, int elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, int elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, int elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, long elong2) => elong1.Value == elong2; - public static bool operator !=(EncLong elong1, long elong2) => elong1.Value != elong2; - public static bool operator >(EncLong elong1, long elong2) => elong1.Value > elong2; - public static bool operator <(EncLong elong1, long elong2) => elong1.Value < elong2; - - public static bool operator ==(EncLong elong1, EncLong elong2) => elong1.Value == elong2.Value; - public static bool operator !=(EncLong elong1, EncLong elong2) => elong1.Value != elong2.Value; - public static bool operator <(EncLong elong1, EncLong elong2) => elong1.Value < elong2.Value; - public static bool operator >(EncLong elong1, EncLong elong2) => elong1.Value > elong2.Value; + public static bool operator ==(EncLong elong1, byte elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, byte elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, byte elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, byte elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, sbyte elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, sbyte elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, sbyte elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, sbyte elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, short elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, short elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, short elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, short elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, ushort elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, ushort elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, ushort elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, ushort elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, uint elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, uint elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, uint elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, uint elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, int elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, int elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, int elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, int elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, long elong2) => elong1.Decrypt == elong2; + public static bool operator !=(EncLong elong1, long elong2) => elong1.Decrypt != elong2; + public static bool operator >(EncLong elong1, long elong2) => elong1.Decrypt > elong2; + public static bool operator <(EncLong elong1, long elong2) => elong1.Decrypt < elong2; + + public static bool operator ==(EncLong elong1, EncLong elong2) => elong1.Decrypt == elong2.Decrypt; + public static bool operator !=(EncLong elong1, EncLong elong2) => elong1.Decrypt != elong2.Decrypt; + public static bool operator <(EncLong elong1, EncLong elong2) => elong1.Decrypt < elong2.Decrypt; + public static bool operator >(EncLong elong1, EncLong elong2) => elong1.Decrypt > elong2.Decrypt; /// assign public static explicit operator EncLong(ulong value) => new EncLong((long)value); @@ -192,17 +189,17 @@ private long Decrypt() public static explicit operator EncLong(double value) => new EncLong((long)value); public static explicit operator EncLong(float value) => new EncLong((long)value); - public static explicit operator ulong(EncLong elong1) => (ulong)elong1.Value; - public static implicit operator long(EncLong elong1) => elong1.Value; - public static explicit operator uint(EncLong elong1) => (uint)elong1.Value; - public static explicit operator int(EncLong elong1) => (int)elong1.Value; - public static explicit operator ushort(EncLong elong1) => (ushort)elong1.Value; - public static explicit operator short(EncLong elong1) => (short)elong1.Value; - public static explicit operator byte(EncLong elong1) => (byte)elong1.Value; - public static explicit operator sbyte(EncLong elong1) => (sbyte)elong1.Value; - public static implicit operator decimal(EncLong elong1) => elong1.Value; - public static implicit operator double(EncLong elong1) => elong1.Value; - public static implicit operator float(EncLong elong1) => elong1.Value; + public static explicit operator ulong(EncLong elong1) => (ulong)elong1.Decrypt; + public static implicit operator long(EncLong elong1) => elong1.Decrypt; + public static explicit operator uint(EncLong elong1) => (uint)elong1.Decrypt; + public static explicit operator int(EncLong elong1) => (int)elong1.Decrypt; + public static explicit operator ushort(EncLong elong1) => (ushort)elong1.Decrypt; + public static explicit operator short(EncLong elong1) => (short)elong1.Decrypt; + public static explicit operator byte(EncLong elong1) => (byte)elong1.Decrypt; + public static explicit operator sbyte(EncLong elong1) => (sbyte)elong1.Decrypt; + public static implicit operator decimal(EncLong elong1) => elong1.Decrypt; + public static implicit operator double(EncLong elong1) => elong1.Decrypt; + public static implicit operator float(EncLong elong1) => elong1.Decrypt; #endregion } \ No newline at end of file From 71a9d892c1321343142c3a7ccc101ec8f5171c5a Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 19:19:29 +0200 Subject: [PATCH 50/53] Benchmark update Removed many comparisons --- .../Benchmark/BenchmarksManager.cs | 20 ++++-------------- .../Benchmark/VarEncBenchmark.cs | 7 ------ Benchmark/VariableEncryption.dll | Bin 151040 -> 150528 bytes 3 files changed, 4 insertions(+), 23 deletions(-) diff --git a/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs index 57c2d9e..8b737bf 100644 --- a/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs +++ b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs @@ -118,7 +118,7 @@ static string[] ResultsAnalysis static public int[] comparisonsChunks = { - 6, 4, 4, 3, 3, 4 + 6, 4, 3, 3, 4 }; static public BenchmarkData[] comparisons = @@ -131,32 +131,20 @@ static string[] ResultsAnalysis new BenchmarkData(benchmarkTypes[8], benchmarkTypes[9]), // decimal new BenchmarkData(benchmarkTypes[10], benchmarkTypes[11]), // string - // EncInt - new BenchmarkData(benchmarkTypes[0], benchmarkTypes[14]), - new BenchmarkData(benchmarkTypes[0], benchmarkTypes[15]), - new BenchmarkData(benchmarkTypes[0], benchmarkTypes[16]), - new BenchmarkData(benchmarkTypes[0], benchmarkTypes[20]), + // Comparing an EncInt with its older versions means nothing + // Now the EncInt is heavier, because it uses a better, heavier encryption + // The same thing applies to the EncFloat and EncDouble // EncLong new BenchmarkData(benchmarkTypes[2], benchmarkTypes[22]), - new BenchmarkData(benchmarkTypes[2], benchmarkTypes[23]), - new BenchmarkData(benchmarkTypes[2], benchmarkTypes[24]), new BenchmarkData(benchmarkTypes[2], benchmarkTypes[25]), - // EncFloat - new BenchmarkData(benchmarkTypes[4], benchmarkTypes[30]), - new BenchmarkData(benchmarkTypes[4], benchmarkTypes[31]), - new BenchmarkData(benchmarkTypes[4], benchmarkTypes[32]), - // EncDecimal new BenchmarkData(benchmarkTypes[8], benchmarkTypes[26]), - new BenchmarkData(benchmarkTypes[8], benchmarkTypes[27]), new BenchmarkData(benchmarkTypes[8], benchmarkTypes[28]), // EncString new BenchmarkData(benchmarkTypes[10], benchmarkTypes[12]), - new BenchmarkData(benchmarkTypes[10], benchmarkTypes[13]), - new BenchmarkData(benchmarkTypes[10], benchmarkTypes[19]), new BenchmarkData(benchmarkTypes[10], benchmarkTypes[21]), }; diff --git a/Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs index b942c58..288c66e 100644 --- a/Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs +++ b/Benchmark/Solution/Variable-Encryption/Benchmark/VarEncBenchmark.cs @@ -31,13 +31,6 @@ public static void StartProgram() static string titleOfApplication = "VarEnc's Benchmarking Console Application"; static private string choiceText = "Type the number of your choice and press ENTER"; - static private string[] sectionTitles = - { - "Step #1: TYPES TO COMPARE", - "Step #2: BENCHMARK DURATION", - "Step #3: BENCHMARK PRESET" - }; - static void PrintSectionTitle() { switch (currentSection) diff --git a/Benchmark/VariableEncryption.dll b/Benchmark/VariableEncryption.dll index 961c87bfaec7af742cff6552afc7b5eec3aa7944..746e10d54972049aa7bdccc912e13039e559963f 100644 GIT binary patch literal 150528 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 literal 151040 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

JaQCa)_U9#S zN}EggT3ugP%@$Gyx}QT|etE7>6!Ce0I~aqvtME@Xi*BdVFXP8=ePO#hBFBw8kKTCd z6IwUqRs;Ql|L2i+39%&x?GzEcm)YGYKsnKE0=!j#<9`zEi5zcRxZ~A#WM7_8fG4AGRKvZw{mZk(y=tqm zji>V5rXu4(Sg|-1wp2&x#UprQI&ssOE%H}%ZqBY8U|Vv(q%eozI(tzi^tyfi$jNs5 zBkJ?&tn|a!c!Io--_<#=d6abVcp&r)>ipFzJdTbhRX?KCD^6+=e~}zS;hO9j%fWuo zEH+7R&Q?SHHKp!svEL}y@Kh*Z+~%*TSffP9#Z$C#s$U$_y>xL10vePqx*5VP`oHi$ W1S|Z+o%z9)U%2G|7x;ewf&T$(^&&d} From 401decc842cb6a584ff9481330e4b6c417940e05 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 19:20:26 +0200 Subject: [PATCH 51/53] Update BenchmarksManager.cs --- .../Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs index 8b737bf..a08d082 100644 --- a/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs +++ b/Benchmark/Solution/Variable-Encryption/Benchmark/BenchmarksManager.cs @@ -118,7 +118,7 @@ static string[] ResultsAnalysis static public int[] comparisonsChunks = { - 6, 4, 3, 3, 4 + 6, 2, 2, 2 }; static public BenchmarkData[] comparisons = From 7f0d17349d39fa8180bfe7c052de61c10bfba645 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Sat, 19 Dec 2020 19:20:29 +0200 Subject: [PATCH 52/53] Update VariableEncryption.dll --- Benchmark/VariableEncryption.dll | Bin 150528 -> 150528 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/Benchmark/VariableEncryption.dll b/Benchmark/VariableEncryption.dll index 746e10d54972049aa7bdccc912e13039e559963f..db9004fa149c6c52514535b87fabfbf6221e3ca0 100644 GIT binary patch delta 22695 zcmeHOeQXp(6o0cVceWI0izsM;Qi1j;p?B@I-3u1E(iV`f8Zc@Ung*-EAdpgx^&Gm$1}72qqFiqaqcr0w#cxh~+~PH3(>sVq-~B1fql>`et_9LVL^I?#A{6!Cp9uK(k-y>e`@TxdRe}?qg#?le=NaXOHyBkxXq^m0 z2(25>>h6b4jM~YliSQMpvKVIx%#bMObF6L({JDHtDUAjOH$xO;uhNoRz3n`f6niB``XDa>{FI# z+G?k1&ywy|yRa?g9Kkr%ay9MUs&`3HIX>*tsE9B{Ung15G&!Bt>K?@PtlgttMKqiF zUvJ-m>%R2Na49$ z|6=5rhh;LHcB>qJBISYfe3g2_zx}Kudm5G%!NLNytPZIOa6qG4ka_^d7OHh}Q^Ft0 zx>0*@4N8!VYcdXAz?B^j|6oesKP(}j)du#}k)MeDDC5mkHr10EzE(!$GB%_6gRE^D zYil&G^;K!A<8TH#{0^#lD^ZplBW}gEk_@&?SIss)Q-(5XSbcs3SP9I{mcCE}GJQB7 zTm+evgZ8&jdmz53XdjL*s60M%ULJl2A>{iafEpfy!1Yf7fv(sPBaIG^&#I2Ke$oDV z+INCwr-f8bB@o@9K6G5}2`@+w5|}Hi8%e%^Pl_Ja0f>N4Jsjo> zlX@Tg0zPkV_{<0mpOHt?$5}KzhM|nneC(oWJSQKgY-}VWBia*;>KBAx4XJ}vm@=So zIV_|$H(SO#qnl5UzUZF7MUY83X#XA~GASsSoG@VBr+Z8pMq>_b#h!4p?+Ky9;?S^8 zk2Zot#fUM=+D4KqK(IG3afE@8_$ELwHee?L6h}9R+4t5cd!1eF!GL$3{JibW0TWxXoI7B?yNV4oicR*!WHF#cs937VElaa7R`> zpQb%NGJ2~PQOVUiTs z@C_NM(t(pLWLS5VQ#N`U(D^B&r2j@Tl#}%&N&GlU{5Xn6>EdUq79I+TA4i$I;No<< zHz?@bD@PhgzH+Xaq)wnXtMZshDcY7rbl{`+V%b2s8ju-iz)mpu@w1Z<3{ugK{Djg7 zBTSj}B*c=AwSKAnt<#>Kgy?B+G>9CD5IibOhG1fT93378lhJz%9dgj(5hQQNH|AObCecSNoPx9)!Q@Q@bsS8jLLCP| z3=WOUVNe&9Eh)SKiPwR~=Zwa%yr%4ShdO*1)CF~%kwqN-TX%zm*DT`J-P#2hqf0zp zCF$XRm34}-?z5as7!Yq;P9_Hqo+pnH zk{rmqNKV-Uqpy&e(%g!Q*)^3l3+8*Pt1D}#E?Q7Cr*=uz>;*4Y6}bw)C zq*6K0Ti`0po8&2Wm*u;?Wd(VK`T4S^%$x7dbIE08&fL-xkIPx?kqcy}H?OqJE4yW7 z=~dzg{Ct(TGY1^r_E5=t+om-(R;1mzy?%2beYAAo-uQ)Idd@26yi$3xEpy|OsTsaQs(N9+Wl( K`j<%O?f(PoDfyEC delta 20669 zcmeHPe{54l9RJ>HY1#O(9|!{h*#-)A%GP$>+Q@KQS2hgD%xJ_IfdxlE5EQ4eKV%@WpQFr(cll_Cg6`mR0t8mCh}t#12Y&!^zPnk3v0XA_xhd>4*(imZa^96@fTWi@b!N@Ho+G`K*eO;oA{pMfB2{1iG9 zE>W?aO83JEBPn!H=z|cT(rZ+j0~e^2N0IYjc0Ym)QE5J`pweY3Jpw1Fw20PQ0#i** z7+HwRtgsB;HX+D_MPMP~6YvfdU#Epn!G0>8rIHT{%>+6t=smeK^GS~2H-mY=5NsAf z@Vk@w=3~fbGQq^QzfU4$HE|md0xwNF%_QGjlLbf9-!$b>eI9s&g{N}-CTk?!h5Tu|N(%4$Dnz(lS5ks*RVl{~#7T5GumJ_+AkQ5MaMNMA~jhfzo zM4ttpJ^cZCvCVU43|HU*r#T-+72y$sEwB$uW1&`*Y{+RI2hF0iEx57UQg91KOn@4z zfPWWD7Fa1te_`o%XceUe!Om{W=#5x65t?lRJ{MaoguSA)K4>{-8STXgJG9yb#33vd zLyss`2A5*Q3aoQNSFwN?h;6ta*C9y0;I4C)f&~~+28&As-F7TZh6AE>3QKpx9i>8< zw=L~ge#@;t;W@~`op??f;OT4tBV5EOf`70Efmj;a*NhG$^Y0W}#qS89>3&=be`Zja z-2548$VKbQ&5O^PtLVYWG;~aV(sSUK9zhP?vYtq(yI}Ke)eTTWZBjjdIDm#QCdMqln3yrKo?OJ3SYIZdtt}Jt z-vm&8O406Dw1J~3cgxL-OLcu@F;Uys;l+wSz8g)`t(&4-grHuokJQ7{r9|04snQ4% z)T?4hp&jgh9eYoL`b51K-viBF1HnEE>h)YmInXw!4^v%u=Mo!{yJA)GG=d?LMgntw zV+(RH`os>=kw6%IGWt|IK9aNW{J+mcr0Fw19$69xM)j#j(|=H7)zqroyf~P1BTZ6! zwun9=$K-|lt1W0;N=t&=?#00i5p|pbMgEg-hep)O221|K$a>uCS!792#gIZf*#Es+ zq|i`2JK}WiYc^B=W1L<`r7WTr$xo*tkdCOOX+6r`S2B6;ykLi(vdezJbcR4-%742SS?G5#Y^byupy9)ff7-+@)Z=Xg`_m>JcM@b9r|0=1K3vqX_gdeAlqSicaeGhhv{X+fwS{6O zDIwY^DQyrEU2v137fuOeRG?i}4^Pjo*)2)kZo0Ee<~KII&eCdexi%P5@-_(OZwZXR zkP;xuirQc(Luz+zPO{PLzKnE`5I07M1P7^wZ`a!wD{6a7?*MdEUkrI|u$&4m7g$aO zLked-Wx3=J>s4{gGxxU#sa$X;Rh*c}xfo4dkUQtGO5+e(Vum7$}Tkz;(u*}cBHY4+-u z4xT>d-}dRvq1@ZJ10#*k1iD)J-zvD;%=+5*yVE|&xwox<>zd)mK6;O@t>l8aqIOAG rOYpF5)iCqR_g#8xO~ygq;N~70WW@ig%pm?6`K)`m?V-U{+ Date: Sat, 19 Dec 2020 19:32:04 +0200 Subject: [PATCH 53/53] Update README.md --- README.md | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 7e00b75..17da77f 100644 --- a/README.md +++ b/README.md @@ -30,23 +30,23 @@ # EncTypes ![img](https://i.imgur.com/F2fxgOn.png) -**A group of classes and structures for storing values while efficiently keeping it encrypted in the memory.** -**In memory, they are saved as a "weird" value that is affected by random values (encryption keys).** +**A group of classes and structures for storing values while efficiently keeping them encrypted in the memory.** +**In memory, they are saved as a "weird" array of bytes that is affected by random values (encryption keys).** **You can find all the EncTypes in [this](https://github.com/JosepeDev/Variable-Encryption/tree/main/EncTypes) folder. You can also use the** -**[benchmark](https://github.com/JosepeDev/Variable-Encryption/wiki/VarEnc's-Benchmark) executable file, to speed test each type.** +**[benchmark](https://github.com/JosepeDev/VarEnc/tree/main/Benchmark) executable file, to speed test each type.** Let's say you want to create a variable for a score inside a video game. With a simple program like CheatEngine and many more, anyone can edit the value of this variable. -This is when you want to use an EncType. Each type does not depend on the other. +This is when you want to use an EncType. Each type does not depend on the other, so you can copy only the types you need. ## Which type to use? -- **EncInt** - For storing an int. Every time you change its value, the random numbers that affect its value change too. +- **EncInt** - For storing an int. Every time you change its value, the random encryption keys that affect its value change too. - **EncLong** - The same thing as the struct above, but for a 64-bit integer (a long). - **EncFloat** - The same thing as the struct above, but for a Single (float). - **EncDouble** - The same thing as the struct above, but for a Double. - **EncDecimal** - The same thing as the struct above, but for a Decimal. -- **EncString** - An EncType class for a string type, that uses an XOR bitwise encryption. +- **EncString** - An EncType class for a string type. You can find the EncTypes folder [here](https://github.com/JosepeDev/Variable-Encryption/tree/main/EncTypes) @@ -94,6 +94,7 @@ encryptedString += "more text"; **But in the background it is encrypted.** **Without you worrying about encryption or decryption, you work with your variables just the same.** **You can also combine and/or compare an EncType with its normal type and vice versa.** +**Every EncType has every method its normal version has.** # Benchmark ![img](https://i.imgur.com/C8YKbnd.png) @@ -113,7 +114,7 @@ After the benchmark is finished, the results will be printed. From there you can ### Performance -I ran a few benchmarks on my Laptop (Intel Core i7-8750h, GTX1060-MaxQ), and these are the results: +I ran a few benchmarks on my Laptop (Intel Core **i7-8750h**, **GTX1060-MaxQ**), and these are the results: | Variable Type | CPS (Changes per second) | |---------------|--------------------------| | EncInt | 5,837,044 | @@ -136,7 +137,7 @@ It may seem heavy but it's **very light** considering its **simple** and **effic In a game where you want to have an encrypted "**score**" for the player, you can just **switch** the score's variable **type** from an **int** to an **EncInt**. They **work** the same, **behave** the same, and have the same **methods** and **functionality**. How many time you change the score variable? How many variables you want to be encrypted? -Even if you'll have **10,000,000 encrypted variables** that you want to change **at once** (it is probably unnecessary to have all of them enc), you can do it and you'll have exactly the same **framerate**. It is a **very light** encryption solution. +Even if you'll have **1,000,000 encrypted variables** that you want to change **at once** (it is probably unnecessary to have all of them enc), you can do it and you'll have exactly the same **framerate**. It is a **very light** encryption solution. ### Example of usage: I **opened** the application from the "**Benchmark**" folder. @@ -163,7 +164,7 @@ It also says shows the **amount of changes** you can perform **in a second** on ### Run benchmark again You can **run again** the same benchmark by pressing **Space** when the results are shown. -You can also run the previous benchmark again by typing **"p"** or **"prev"**. +You can also run the previous benchmark again by typing **"p"** or **"prev"** in the first menu. ### Multiple choices at once I could perform the same benchmark as before, by inputting all the choices at once. @@ -178,7 +179,7 @@ By typing **"size"** or **"s"** in the opening menu, you can see the sizes of ev ### Files You can lunch the benchmark executable from [here](https://github.com/JosepeDev/Variable-Encryption/tree/main/Benchmark) -You can also see the Benchmark Application's Solution in [this](https://github.com/JosepeDev/VarEnc/tree/main/Benchmark/Solution%20(Not%20very%20organized)) folder +You can also see the Benchmark Application's Solution in [this](https://github.com/JosepeDev/VarEnc/tree/main/Benchmark/Solution) folder # Documentations **Every EncType contains the same methods and fields as its normal type.**