SHARE
TWEET

Untitled

a guest May 12th, 2018 234 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Drawing;
  6. using System.Threading;
  7. using System.Text;
  8. using System.Windows.Forms;
  9.  
  10. namespace Starcode
  11. {
  12.     public partial class Form1 : Form
  13.     {
  14.         String gv_Rank;
  15.         int gv_Server;
  16.         string gv_F9242429;
  17.         int iCheck;
  18.         private Thread workerThread = null;
  19.         private bool stopProcess = false;
  20.         public Form1()
  21.         {
  22.             InitializeComponent();
  23.             textBox21.Text = "0ek41GMIGDL8BI7J1GINFDILC37IF3I8DDHMDDMKF3MNGFJIFDLKC3LIC37KGHJ8F37NCGLMFEKNEHHNBIJMDF7LDF7KEEKKGIK813MNBIHI1F78BHJL1EKKGEJNFH781EI8";
  24.             ToolTip ToolTip1 = new ToolTip();
  25.             updateStatusDelegate = new UpdateStatusDelegate(UpdateStatus);
  26.         }
  27.         string[] gv_91D08AC7 = {
  28.             "A",
  29.             "A",
  30.             "B",
  31.             "C",
  32.             "D",
  33.             "E",
  34.             "F",
  35.             "0"
  36.         };
  37.         string[] gv_86A87611 = {
  38.             "1",
  39.             "1",
  40.             "2",
  41.             "3",
  42.             "4",
  43.             "5",
  44.             "6",
  45.             "7",
  46.             "8",
  47.             "9"
  48.         };
  49.         void gf_54138E7E(string lp_5378CC2A)
  50.         {
  51.             gv_F9242429 = lp_5378CC2A;
  52.             gv_86A87611[1] = "1";
  53.             gv_86A87611[2] = "2";
  54.             gv_86A87611[3] = "3";
  55.             gv_86A87611[4] = "4";
  56.             gv_86A87611[5] = "5";
  57.             gv_86A87611[6] = "6";
  58.             gv_86A87611[7] = "7";
  59.             gv_86A87611[8] = "8";
  60.             gv_86A87611[9] = "9";
  61.             gv_91D08AC7[1] = "A";
  62.             gv_91D08AC7[2] = "B";
  63.             gv_91D08AC7[3] = "C";
  64.             gv_91D08AC7[4] = "D";
  65.             gv_91D08AC7[5] = "E";
  66.             gv_91D08AC7[6] = "F";
  67.             gv_91D08AC7[7] = "0";
  68.         }
  69.         string gf_F0A5FB9B(string lp_DEC944FF)
  70.         {
  71.             string lv_2F97D1EF;
  72.             lv_2F97D1EF = "";
  73.             lv_2F97D1EF = lp_DEC944FF;
  74.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_91D08AC7[1], gv_91D08AC7[7]);
  75.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_91D08AC7[2], gv_91D08AC7[7]);
  76.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_91D08AC7[3], gv_91D08AC7[7]);
  77.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_91D08AC7[4], gv_91D08AC7[7]);
  78.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_91D08AC7[5], gv_91D08AC7[7]);
  79.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_91D08AC7[6], gv_91D08AC7[7]);
  80.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_86A87611[9], gv_86A87611[1]);
  81.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_86A87611[8], gv_86A87611[1]);
  82.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_86A87611[7], gv_86A87611[1]);
  83.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_86A87611[6], gv_86A87611[1]);
  84.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_86A87611[5], gv_86A87611[1]);
  85.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_86A87611[4], gv_86A87611[1]);
  86.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_86A87611[3], gv_86A87611[1]);
  87.             lv_2F97D1EF = lv_2F97D1EF.Replace(gv_86A87611[2], gv_86A87611[1]);
  88.             return lv_2F97D1EF;
  89.         }
  90.         string gf_9103AE33(string lp_8E54FB4F)
  91.         {
  92.             string auto2483138D_val;
  93.             string lv_500518A5;
  94.             int lv_865A2B09;
  95.             lv_500518A5 = "";
  96.             lv_865A2B09 = 1;
  97.             for (; lv_865A2B09 <= 72; lv_865A2B09 += 1)
  98.             {
  99.                 auto2483138D_val = StringSub(lp_8E54FB4F, lv_865A2B09, lv_865A2B09);
  100.                 if (auto2483138D_val == "0")
  101.                 {
  102.                     lv_500518A5 = (lv_500518A5 + gv_91D08AC7[RandomInt(1, 7)]);
  103.                 }
  104.                 else if (auto2483138D_val == "1")
  105.                 {
  106.                     lv_500518A5 = (lv_500518A5 + gv_86A87611[RandomInt(1, 9)]);
  107.                 }
  108.                 else if (auto2483138D_val == "")
  109.                 {
  110.                     lv_500518A5 = (lv_500518A5 + gv_91D08AC7[RandomInt(1, 7)]);
  111.                 }
  112.                 else
  113.                 {
  114.                     lv_500518A5 = (lv_500518A5 + StringSub(lp_8E54FB4F, lv_865A2B09, lv_865A2B09));
  115.                 }
  116.             }
  117.             return lv_500518A5;
  118.         }
  119.         int RandomInt(int min, int max)
  120.         {
  121.             return (new Random().Next(min, max + 1));
  122.         }
  123.         string lib1_gf_StarcodeEncryptString(string lp_toEncrypt, string lp_key)
  124.         {
  125.             return STARCODE_Encrypt(lp_toEncrypt, lp_key);
  126.         }
  127.         string lib1_gf_StarcodeCompressString(string lp_toCompress)
  128.         {
  129.             return STARCODE_Base10ToN(lp_toCompress, STARCODE_AlphabetLength);
  130.         }
  131.         string lib1_gf_StarcodeHashString(string lp_toHash, int lp_securityLevel)
  132.         {
  133.             return
  134.             STARCODE_Hash(lp_toHash, lp_securityLevel) + lp_toHash;
  135.         }
  136.         string lib1_gf_StarcodeRemoveHashfromString(string lp_string, int lp_securityLevel)
  137.         {
  138.             return StringSub(lp_string, lp_securityLevel + 1, StringLength(lp_string));
  139.         }
  140.         bool lib1_gf_StarcodeValidateString(string lp_toCheck, int lp_securityLevel)
  141.         {
  142.             string oldHash = StringSub(lp_toCheck, 1, lp_securityLevel);
  143.             string newHash = STARCODE_Hash(StringSub(lp_toCheck, lp_securityLevel + 1, StringLength(lp_toCheck)), lp_securityLevel);
  144.             return newHash == oldHash;
  145.         }
  146.         string lib1_gf_StarcodeDecryptString(string lp_toDecrypt, string lp_key)
  147.         {
  148.             return STARCODE_Decrypt(lp_toDecrypt, lp_key);
  149.         }
  150.         string lib1_gf_StarcodeDecompressString(string lp_toDecompress)
  151.         {
  152.             return STARCODE_BaseNTo10(lp_toDecompress, STARCODE_AlphabetLength);
  153.         }
  154.         const bool c_stringCase = true;
  155.         const bool c_stringNoCase = false;
  156.         string StringSub(string val, int start, int end)
  157.         {
  158.             string result = string.Empty;
  159.             try
  160.             {
  161.                 return val.Substring(start - 1, end - start + 1);
  162.             }
  163.             catch (Exception ex)
  164.             {
  165.                 result = string.Empty;
  166.             }
  167.             return result;
  168.         }
  169.         int StringToInt(string val)
  170.         {
  171.             try
  172.             {
  173.                 return int.Parse(val);
  174.             }
  175.             catch
  176.             {
  177.                 return 0;
  178.             }
  179.         }
  180.         string IntToString(int val)
  181.         {
  182.             return val.ToString();
  183.         }
  184.         int StringLength(string val)
  185.         {
  186.             return val.Length;
  187.         }
  188.         const int c_stringNotFound = -1;
  189.         int StringFind(string txt, string val, bool casesens)
  190.         {
  191.             if (txt.Contains(val)) return txt.IndexOf(val) + 1;
  192.             else return c_stringNotFound;
  193.         }
  194.         const string STARCODE_Alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!$%/()=?,.-;:_^#+* @{[]}|~`";
  195.         int STARCODE_AlphabetLength = STARCODE_Alphabet.Length;
  196.         string STARCODE_CurrentCode = "0";
  197.         string STARCODE_fill(string s, int i)
  198.         {
  199.             int c = i - StringLength(s);
  200.             string t = "";
  201.             while (c > 0)
  202.             {
  203.                 t += "0";
  204.                 c -= 1;
  205.             }
  206.             return t + s;
  207.         }
  208.         string STARCODE_cut(string s)
  209.         {
  210.             int i = 1;
  211.             while (i < StringLength(s) && StringSub(s, i, i) == "0")
  212.             {
  213.                 i += 1;
  214.             }
  215.             return StringSub(s, i, StringLength(s));
  216.         }
  217.         string STARCODE_BigNumAdd(string number, string addition)
  218.         {
  219.             int i = 0;
  220.             int c = 0;
  221.             int carry = 0;
  222.             int ln = StringLength(number);
  223.             int la = StringLength(addition);
  224.             string result = "";
  225.             if (la > ln)
  226.             {
  227.                 number = STARCODE_fill(number, la);
  228.                 ln = la;
  229.             }
  230.             else if (ln > la)
  231.             {
  232.                 addition = STARCODE_fill(addition, ln);
  233.                 la = ln;
  234.             }
  235.             while (i < ln)
  236.             {
  237.                 c = StringToInt(StringSub(number, ln - i, ln - i)) + StringToInt(StringSub(addition, la - i, la - i));
  238.                 result = IntToString((c + carry) % 10) + result;
  239.                 carry = (c + carry) / 10;
  240.                 i += 1;
  241.             }
  242.             if (carry > 0)
  243.             {
  244.                 result = IntToString(carry) + result;
  245.             }
  246.             return result;
  247.         }
  248.         string STARCODE_BigNumSubtract(string number, string subtraction)
  249.         {
  250.             int i = 0;
  251.             int c = 0;
  252.             int carry = 0;
  253.             int ln = StringLength(number);
  254.             int ls = StringLength(subtraction);
  255.             string result = "";
  256.             if (ls > ln)
  257.             {
  258.                 number = STARCODE_fill(number, ls);
  259.                 ln = ls;
  260.             }
  261.             else if (ln > ls)
  262.             {
  263.                 subtraction = STARCODE_fill(subtraction, ln);
  264.                 ls = ln;
  265.             }
  266.             while (i < ln)
  267.             {
  268.                 c = StringToInt(StringSub(number, ln - i, ln - i)) - StringToInt(StringSub(subtraction, ls - i, ls - i));
  269.                 c -= carry;
  270.                 if (c < 0)
  271.                 {
  272.                     carry = 1;
  273.                     c += 10;
  274.                 }
  275.                 else
  276.                 {
  277.                     carry = 0;
  278.                 }
  279.                 result = IntToString(c) + result;
  280.                 i += 1;
  281.             }
  282.             result = STARCODE_cut(result);
  283.             return result;
  284.         }
  285.         string STARCODE_BigNumMultiply(string number, string multi)
  286.         {
  287.             int i = 0;
  288.             int m = StringToInt(multi);
  289.             int c = 0;
  290.             int carry = 0;
  291.             int ln = StringLength(number);
  292.             int lm = StringLength(multi);
  293.             string result = "";
  294.             while (i < ln)
  295.             {
  296.                 c = (StringToInt(StringSub(number, ln - i, ln - i)) * m) + carry;
  297.                 result = IntToString((c % 10)) + result;
  298.                 carry = c / 10;
  299.                 i += 1;
  300.             }
  301.             if (carry > 0)
  302.             {
  303.                 result = IntToString(carry) + result;
  304.             }
  305.             if (multi == "0")
  306.             {
  307.                 result = "0";
  308.             }
  309.             return result;
  310.         }
  311.         string STARCODE_BigNumDivive(string number, string div)
  312.         {
  313.             int i = 1;
  314.             int d = StringToInt(div);
  315.             int c = 0;
  316.             int carry = 0;
  317.             int ln = StringLength(number);
  318.             int ld = StringLength(div);
  319.             string result = "";
  320.             while (i <= ln)
  321.             {
  322.                 c = (StringToInt(StringSub(number, i, i))) + carry * 10;
  323.                 result += IntToString(c / d);
  324.                 carry = c % d;
  325.                 i += 1;
  326.             }
  327.             if (carry > 0)
  328.             {
  329.             }
  330.             result = STARCODE_cut(result);
  331.             return result;
  332.         }
  333.         string STARCODE_BigNumModulo(string number, string div)
  334.         {
  335.             int i = 1;
  336.             int d = StringToInt(div);
  337.             int c = 0;
  338.             int carry = 0;
  339.             int ln = StringLength(number);
  340.             int ld = StringLength(div);
  341.             while (i <= ln)
  342.             {
  343.                 c = (StringToInt(StringSub(number, i, i))) + carry * 10;
  344.                 carry = c % d;
  345.                 i += 1;
  346.             }
  347.             return IntToString(carry);
  348.         }
  349.         string STARCODE_BigNumPower(string number, int pow)
  350.         {
  351.             string result = number;
  352.             if (pow > 0)
  353.             {
  354.                 while (pow > 1)
  355.                 {
  356.                     result = STARCODE_BigNumMultiply(result, number);
  357.                     pow -= 1;
  358.                 }
  359.                 return result;
  360.             }
  361.             else
  362.             {
  363.                 return "1";
  364.             }
  365.         }
  366.         string STARCODE_Encode(string s, int i, int max)
  367.         {
  368.             return STARCODE_BigNumAdd(STARCODE_BigNumMultiply(s, IntToString(max)), IntToString(i));
  369.         }
  370.         int STARCODE_Decode(string s, int max)
  371.         {
  372.             return StringToInt(STARCODE_BigNumModulo(s, IntToString(max)));
  373.         }
  374.         string STARCODE_Decode2(string s, int max)
  375.         {
  376.             return STARCODE_BigNumDivive(s, IntToString(max));
  377.         }
  378.         string STARCODE_chr(int i)
  379.         {
  380.             return StringSub(STARCODE_Alphabet, i + 1, i + 1);
  381.         }
  382.         int STARCODE_ord(string i)
  383.         {
  384.             return StringFind(STARCODE_Alphabet, i, c_stringCase) - 1;
  385.         }
  386.         string STARCODE_shiftForward(string s, string k)
  387.         {
  388.             return STARCODE_chr((STARCODE_ord(s) + STARCODE_ord(k)) % STARCODE_AlphabetLength);
  389.         }
  390.         string STARCODE_shiftBackward(string s, string k)
  391.         {
  392.             int c = STARCODE_ord(s) - STARCODE_ord(k);
  393.             if (c < 0)
  394.             {
  395.                 return STARCODE_chr((c + STARCODE_AlphabetLength) % STARCODE_AlphabetLength);
  396.             }
  397.             else
  398.             {
  399.                 return STARCODE_chr(c % STARCODE_AlphabetLength);
  400.             }
  401.         }
  402.         string STARCODE_Encrypt(string s, string key)
  403.         {
  404.             int i = 1;
  405.             int ls = StringLength(s);
  406.             int lk = StringLength(key);
  407.             string result = "";
  408.             while (i <= ls)
  409.             {
  410.                 result += STARCODE_shiftForward(StringSub(s, i, i), StringSub(key, ((i - 1) % lk) + 1, ((i - 1) % lk) + 1));
  411.                 i += 1;
  412.             }
  413.             return result;
  414.         }
  415.         string STARCODE_Decrypt(string s, string key)
  416.         {
  417.             int i = 1;
  418.             int ls = StringLength(s);
  419.             int lk = StringLength(key);
  420.             string result = "";
  421.             while (i <= ls)
  422.             {
  423.                 result += STARCODE_shiftBackward(StringSub(s, i, i), StringSub(key, ((i - 1) % lk) + 1, ((i - 1) % lk) + 1));
  424.                 i += 1;
  425.             }
  426.             return result;
  427.         }
  428.         string STARCODE_Base10ToN(string current, int baseN)
  429.         {
  430.             string n = IntToString(baseN);
  431.             string remainder = "";
  432.             string result = "";
  433.             while (current != "0")
  434.             {
  435.                 remainder = STARCODE_BigNumModulo(current, n);
  436.                 result = STARCODE_chr(StringToInt(remainder)) + result;
  437.                 current = STARCODE_BigNumDivive(current, n);
  438.             }
  439.             return result;
  440.         }
  441.         string STARCODE_BaseNTo10(string current, int baseN)
  442.         {
  443.             string result = "0";
  444.             string baseS = IntToString(baseN);
  445.             int l = StringLength(current);
  446.             int i = 1;
  447.             while (i <= l)
  448.             {
  449.                 result = STARCODE_BigNumAdd(result, STARCODE_BigNumMultiply(STARCODE_BigNumPower(baseS, l - i), IntToString(STARCODE_ord(StringSub(current, i, i)))));
  450.                 i += 1;
  451.             }
  452.             return result;
  453.         }
  454.         string STARCODE_Hash(string toHash, int keyLength)
  455.         {
  456.             int i = StringLength(toHash);
  457.             string result = "0";
  458.             while (i > 0)
  459.             {
  460.                 result = STARCODE_BigNumAdd(result, IntToString(STARCODE_ord(StringSub(toHash, i, i)) * i));
  461.                 i -= 1;
  462.             }
  463.             return STARCODE_fill(
  464.                 STARCODE_Base10ToN(
  465.                     STARCODE_BigNumModulo(result, IntToString(Pow(STARCODE_AlphabetLength, keyLength))), STARCODE_AlphabetLength), keyLength);
  466.         }
  467.         // Old Pow
  468.         //int Pow(int val, int pow)
  469.         //{
  470.         //    return (int)Math.Pow(val, pow);
  471.         //
  472.         //}
  473.         int Pow(int val, int pow)
  474.         {
  475.             return Convert.ToInt32(Math.Pow((double)val, (double)pow));
  476.         }
  477.         private void button3_Click(object sender, EventArgs e)
  478.         {
  479.             string XP_Generate = textBox8.Text;
  480.             XP_Generate = lib1_gf_StarcodeRemoveHashfromString(XP_Generate, StringToInt(textBox9.Text));
  481.             XP_Generate = lib1_gf_StarcodeDecryptString(XP_Generate, textBox6.Text);
  482.             textBox10.Text = XP_Generate;
  483.         }
  484.         private void button4_Click(object sender, EventArgs e)
  485.         {
  486.             int lv_Handle3 = StringToInt(StringSub(textBox2.Text, 7, 10));
  487.             if (lv_Handle3 <= 5000)
  488.             {
  489.                 lv_Handle3 += 2197;
  490.             }
  491.             else
  492.             {
  493.                 lv_Handle3 -= 3416;
  494.             }
  495.             textBox3.Text = IntToString(lv_Handle3);
  496.         }
  497.         private void button5_Click(object sender, EventArgs e)
  498.         {
  499.             int lv_Handle2 = StringToInt(StringSub(textBox5.Text, 7, 10));
  500.             if (lv_Handle2 <= 5000)
  501.             {
  502.                 lv_Handle2 += 3719;
  503.             }
  504.             else
  505.             {
  506.                 lv_Handle2 -= 2648;
  507.             }
  508.             textBox7.Text = IntToString(lv_Handle2);
  509.         }
  510.         private void textBox13_TextChanged(object sender, EventArgs e) { }
  511.         private void button6_Click(object sender, EventArgs e)
  512.         {
  513.             string XP_Generate = textBox13.Text;
  514.             XP_Generate = lib1_gf_StarcodeEncryptString(XP_Generate, textBox11.Text);
  515.             XP_Generate = lib1_gf_StarcodeHashString(XP_Generate, StringToInt(textBox12.Text));
  516.             textBox14.Text = XP_Generate;
  517.         }
  518.         private void button8_Click(object sender, EventArgs e)
  519.         {
  520.             string GemCode = textBox17.Text;
  521.             GemCode = gf_F0A5FB9B(GemCode);
  522.             textBox18.Text = GemCode;
  523.         }
  524.         private void button9_Click(object sender, EventArgs e)
  525.         {
  526.             string GemCode = textBox19.Text;
  527.             GemCode = gf_9103AE33(GemCode);
  528.             textBox20.Text = GemCode;
  529.         }
  530.         private void button10_Click(object sender, EventArgs e)
  531.         {
  532.             stopProcess = false;
  533.             workerThread = new Thread(new ThreadStart(HeavyOperation));
  534.             workerThread.Start();
  535.         }
  536.         private void HeavyOperation()
  537.         {
  538.             g.XP_Generate = textBox21.Text;
  539.             g.XP = g.XP_Generate;
  540.             int i = 0;
  541.             while (i < 99999)
  542.             {
  543.                 if (!stopProcess)
  544.                 {
  545.                     // Thread.Sleep(100);
  546.                     g.XP = g.XP_Generate;
  547.                     g.XP = lib1_gf_StarcodeRemoveHashfromString(g.XP, 4);
  548.                     g.XP = lib1_gf_StarcodeDecryptString(g.XP, IntToString(i));
  549.                     Invoke(updateStatusDelegate);
  550.                     i++;
  551.                     iCheck = i;
  552.                 }
  553.                 else
  554.                 {
  555.                     workerThread.Abort();
  556.                 }
  557.             }
  558.         }
  559.         private void UpdateStatus()
  560.         {
  561.             textBox23.Text = IntToString(iCheck);
  562.             textBox22.Text = gf_F0A5FB9B(g.XP);
  563.             if (gf_F0A5FB9B(g.XP).Contains("000000000000000000000000000000000000"))
  564.             {
  565.                 this.textBox24.Text += iCheck + " ";
  566.             }
  567.         }
  568.         private void button11_Click(object sender, EventArgs e)
  569.         {
  570.             stopProcess = true;
  571.         }
  572.         private delegate void UpdateStatusDelegate();
  573.         private UpdateStatusDelegate updateStatusDelegate = null;
  574.         private void label9_Click(object sender, EventArgs e) { }
  575.         private void label18_Click(object sender, EventArgs e) { }
  576.     }
  577.     public static class g
  578.     {
  579.         public
  580.         const Int32 BUFFER_SIZE = 10; // Unmodifiable
  581.         public static string XP_Generate;
  582.         public static string XP;
  583.         public static readonly String CODE_PREFIX = "US-"; // Unmodifiable
  584.     }
  585. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top