public SBOBet(string text1, ISynchronizeInvoke invoke1, string text2, string text3, string text4, bool flag1, bool flag2, bool flag3, bool flag4, bool flag5, bool flag6, bool flag7, bool flag8, EnumCollection.eSpiderMethod method1, int num2, int num3, int num4, int num1)
 {
     this._strLoginName = "";
     this._strSynidNextRunning = "-1";
     this._strSynidNextToday = "-1";
     this._strSynidNextEarly = "-1";
     this._strSynidNextRunningTmp = "-1";
     this._strSynidNextTodayTmp = "-1";
     this._strSynidNextEarlyTmp = "-1";
     this._objMatchOutRightList = new List<MatchOutRight>();
     this._objMatchOddEvenList = new List<MatchOddEven>();
     this._objMatchTotalGoalList = new List<MatchTotalGoal>();
     this._isToSaveBetList = false;
     try
     {
         this.DoNew(text1, "SBOBet", num1, invoke1, text2, text3, text4);
         this.Init(flag1, flag2, flag3, flag4, flag5, flag6, flag7, flag8, method1, num2, num3, num4);
     }
     catch (Exception exception1)
     {
         ProjectData.SetProjectError(exception1);
         Exception exception = exception1;
         base._objErrorLogger.write(base._strName + ": EXCEPTION IN New: " + exception.Message);
         this.WriteProgramLogger(base._strName + ": EXCEPTION IN New: " + exception.Message);
         ProjectData.ClearProjectError();
     }
 }

 public void Bet(string text2, string text3, string text1, MatchBetNew new2, MatchNew new1, EnumCollection.eBetTarget target1)
 {
     try
     {
         string requestUriString = "";
         requestUriString = base._strRootURL + text1;
         this.WriteProgramLogger(requestUriString);
         HttpWebRequest request = (HttpWebRequest) WebRequest.Create(requestUriString);
         request.Timeout = 0x4e20;
         request.Method = "POST";
         request.UserAgent = "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.16) Gecko/2009120208 Firefox/3.0.16";
         request.Headers.Add("Accept-Language", "en-us");
         request.Headers.Add("Accept-Encoding", "gzip, deflate");
         request.Headers.Add("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
         request.ContentType = "application/x-www-form-urlencoded";
         request.KeepAlive = true;
         request.Referer = text2;
         request.ContentLength = text3.Length;
         request.AllowAutoRedirect = true;
         request.Headers["Cookie"] = base._objCookieList.ToString();
         WebRequestStateEx2 state = new WebRequestStateEx2("Bet", request, text3, EnumCollection.eBetType.HDP, target1, new1, null, null, new2);
         ThreadPool.RegisterWaitForSingleObject(request.BeginGetRequestStream(new AsyncCallback(this.ReadCallBackBet), state).AsyncWaitHandle, new WaitOrTimerCallback(this.TimeoutCallBackEx2), state, 0x4e20, true);
         base.allDone.WaitOne();
     }
     catch (Exception exception1)
     {
         ProjectData.SetProjectError(exception1);
         Exception exception = exception1;
         base._isBetting = false;
         base._objErrorLogger.write(base._strName + ": EXCEPTION IN Bet: " + exception.Message);
         this.WriteProgramLogger(base._strName + ": EXCEPTION IN Bet: " + exception.Message);
         this.RaiseEventBetComplete(base._strName, false, new1, new2);
         ProjectData.ClearProjectError();
     }
 }

 public BetAmountStyleManagerUI(EnumCollection.eBetAmountStyle style1, bool flag1, int num1, string text1)
 {
     this._objBetAmountStyle = style1;
     this._isPercentOptionDisabled = flag1;
     this._intExtendedValue = num1;
     this._strSportBook = text1;
 }

 public PerMatchLimitManagerUI(int num1, EnumCollection.ePerMatchLimitType type1, decimal decimal1, decimal decimal2)
 {
     this._intPermatchLimitMethod = num1;
     this._objPerMatchLimitType = type1;
     this._dclAmountLimit = decimal1;
     this._intCountLimit = Convert.ToInt32(decimal2);
 }

 public AgentToClientBet(MatchBetNew new1, MatchNew new2, EnumCollection.eBetAmountStyle style1, int num1, int num2, string text1, FollowOddsOption option1)
 {
     this._intMaxBettingAttempt = 5;
     this._objBetAmountStyle = EnumCollection.eBetAmountStyle.Fixed;
     this._intBetAmountValue = 0;
     this._objMatchBet = new MatchBetNew();
     this._objMatchClient = new MatchNew();
     this._intBettingAttempt = 0;
     this._intBetSuccessCount = 0;
     this._intTargetAmount = 0;
     this._intBettedAmount = 0;
     this._intLastBetSuccessAmount = 0;
     this._isRemoved = false;
     this._strMeaningfulStatus = "";
     this._strActionStatus = "";
     this._isWaitingReset = false;
     this._objFollowOddsOption = new FollowOddsOption();
     this._objMatchBet = new1;
     this._objMatchClient = new2;
     this._objBetAmountStyle = style1;
     this._intBetAmountValue = num1;
     this._intMaxBettingAttempt = num2;
     this._strActionStatus = text1;
     this._objFollowOddsOption = option1;
     this.UpdateTargetAmount();
 }

 public void Bet(string text1, MatchBetNew new2, MatchNew new1, EnumCollection.eBetTarget target1)
 {
     try
     {
         string requestUriString = "";
         base._isBetting = true;
         base._datBetStart = DateTime.Now;
         requestUriString = base._strRootURL + text1;
         CommonFunction.Log(requestUriString);
         HttpWebRequest request = (HttpWebRequest) WebRequest.Create(requestUriString);
         request.Timeout = 0x4e20;
         request.Method = "GET";
         request.UserAgent = "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.16) Gecko/2009120208 Firefox/3.0.16";
         request.Accept = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
         request.Headers.Add("Accept-Language", "en-gb,en;q=0.5");
         request.Headers.Add("Accept-Encoding", "gzip, deflate");
         request.Headers.Add("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
         request.Headers["Cookie"] = base._objCookieList.ToString();
         request.Referer = base._strRootURL + "/english/index.php?p=betting_entry";
         request.ContentType = "application/x-www-form-urlencoded";
         request.ContentLength = 0L;
         WebRequestStateEx2 state = new WebRequestStateEx2("Bet", request, "", EnumCollection.eBetType.HDP, target1, new1, null, null, new2);
         ThreadPool.RegisterWaitForSingleObject(request.BeginGetResponse(new AsyncCallback(this.RequestCompleteBet), state).AsyncWaitHandle, new WaitOrTimerCallback(this.TimeoutCallBackEx2), state, 0x2710, true);
     }
     catch (Exception exception1)
     {
         ProjectData.SetProjectError(exception1);
         Exception exception = exception1;
         base._isBetting = false;
         base._objErrorLogger.write(base._strName + ": EXCEPTION IN Bet: " + exception.Message);
         this.WriteProgramLogger(base._strName + ": EXCEPTION IN Bet: " + exception.Message);
         this.RaiseEventBetComplete(base._strName, false, new1, new2);
         ProjectData.ClearProjectError();
     }
 }

        void WriteBindings(DelegateCollection delegates, FunctionCollection wrappers, EnumCollection enums)
        {
            Console.WriteLine("Writing bindings to {0}", Settings.OutputPath);
            if (!Directory.Exists(Settings.OutputPath))
                Directory.CreateDirectory(Settings.OutputPath);

            // Hack: Fix 3dfx extension category so it doesn't start with a digit
            if (wrappers.ContainsKey("3dfx"))
            {
                var three_dee_fx = wrappers["3dfx"];
                wrappers.Remove("3dfx");
                wrappers.Add(DigitPrefix + "3dfx", three_dee_fx);
            }

            using (var sw = sw_h)
            {
                WriteLicense(sw);

                sw.WriteLine("package {0}.{1};", Settings.OutputNamespace, Settings.GLClass);
                sw.WriteLine();
                sw.WriteLine("import java.nio.*;");
                sw.WriteLine();

                WriteDefinitions(sw, enums, wrappers, Type.CSTypes);

                sw.Flush();
                sw.Close();
            }

            string output_header = Path.Combine(Settings.OutputPath, OutputFileHeader);
            Move(sw_h.File, output_header);
        }

 public EnumCollection Process(EnumCollection enums)
 {
     var nav = new XPathDocument(Overrides).CreateNavigator();
     enums = ProcessNames(enums, nav);
     enums = ProcessConstants(enums, nav);
     return enums;
 }

 public FollowOddsOption(EnumCollection.eFollowOddsOption option1, double num1)
 {
     this._objFollowOddsOption = EnumCollection.eFollowOddsOption.None;
     this._dblOddsValue = 0.0;
     this._objFollowOddsOption = option1;
     this._dblOddsValue = num1;
 }

        public FunctionCollection Process(DelegateCollection delegates, EnumCollection enums)
        {
            Console.WriteLine("Processing delegates.");
            var nav = new XPathDocument(Overrides).CreateNavigator();
            foreach (var d in delegates.Values)
            {
                var function_override = GetFuncOverride(nav, d);
		if (function_override != null) {
                    string obsolete = function_override.GetAttribute ("obsolete", "");
                    if (!string.IsNullOrEmpty (obsolete))
                        d.Obsolete = obsolete;
                }

                TranslateReturnType(nav, d, enums);
                TranslateParameters(nav, d, enums);
            }

            Console.WriteLine("Generating wrappers.");
            var wrappers = CreateWrappers(delegates, enums);
            Console.WriteLine("Creating CLS compliant overloads.");
            wrappers = CreateCLSCompliantWrappers(wrappers, enums);
            Console.WriteLine("Removing non-CLS compliant duplicates.");

            return MarkCLSCompliance(wrappers);
        }

        public Generator(Settings settings, string dirName)
        {
            if (settings == null)
                throw new ArgumentNullException("settings");
            if (dirName == null)
                dirName = "GL2";

            Settings = settings.Clone();

            glTypemap = "GL2/gl.tm";
            csTypemap = Settings.LanguageTypeMapFile;

            enumSpec = Path.Combine(dirName, "signatures.xml");
            enumSpecExt = String.Empty;
            glSpec = Path.Combine(dirName, "signatures.xml");
            glSpecExt = String.Empty;
            Settings.OverridesFile = Path.Combine(dirName, "overrides.xml");

            Settings.ImportsClass = "Core";
            Settings.DelegatesClass = "Delegates";
            Settings.OutputClass = "GL";

            Delegates = new DelegateCollection();
            Enums = new EnumCollection();
            Wrappers = new FunctionCollection();

            SpecReader = new XmlSpecReader(Settings);
        }

 private void FrmUI_OKClicked(string text1, string text2, EnumCollection.eMemberPosition position1)
 {
     OKClickedEventHandler oKClickedEvent = this.OKClickedEvent;
     if (oKClickedEvent != null)
     {
         oKClickedEvent(text1, text2, position1);
     }
 }

 private void OKClicked_Done(EnumCollection.eBetAmountStyle style1, int num1)
 {
     OKClickedEventHandler oKClickedEvent = this.OKClickedEvent;
     if (oKClickedEvent != null)
     {
         oKClickedEvent(style1, num1);
     }
 }

 private void FrmUI_OKClicked(decimal decimal1, EnumCollection.eProgramAction action1)
 {
     OKClickedEventHandler oKClickedEvent = this.OKClickedEvent;
     if (oKClickedEvent != null)
     {
         oKClickedEvent(decimal1, action1);
     }
 }

 private void FrmUI_OKClicked(AccountInformationList list1, EnumCollection.eOddsType type1)
 {
     OKClickedEventHandler oKClickedEvent = this.OKClickedEvent;
     if (oKClickedEvent != null)
     {
         oKClickedEvent(list1, type1);
     }
 }

 private void FrmUI_OKClicked(int num1, EnumCollection.ePerMatchLimitType type1, decimal decimal1, int num2)
 {
     OKClickedEventHandler oKClickedEvent = this.OKClickedEvent;
     if (oKClickedEvent != null)
     {
         oKClickedEvent(num1, type1, decimal1, num2);
     }
 }

        void WriteBindings(DelegateCollection delegates, FunctionCollection wrappers, EnumCollection enums)
        {
            Console.WriteLine("Writing bindings to {0}", Settings.OutputPath);
            if (!Directory.Exists(Settings.OutputPath))
                Directory.CreateDirectory(Settings.OutputPath);

            // Hack: Fix 3dfx extension category so it doesn't start with a digit
            if (wrappers.ContainsKey("3dfx"))
            {
                var three_dee_fx = wrappers["3dfx"];
                wrappers.Remove("3dfx");
                wrappers.Add(DigitPrefix + "3dfx", three_dee_fx);
            }

            Settings.DefaultOutputNamespace = "OpenTK";

            // Enums
            using (var sw = sw_h_enums)
            {
                WriteEnums(sw, enums);
                sw.Flush();
                sw.Close();
            }

            // Core definitions
            using (var sw = sw_h)
            {
                WriteDefinitions(sw, enums, wrappers, Type.CSTypes, false);
                sw.Flush();
                sw.Close();
            }

            // Compatibility definitions
            using (var sw = sw_h_compat)
            {
                WriteDefinitions(sw, enums, wrappers, Type.CSTypes, true);
                sw.Flush();
                sw.Close();
            }

            // Core & compatibility declarations
            using (var sw = sw_cpp)
            {
                WriteDeclarations(sw, wrappers, Type.CSTypes);
                sw.Flush();
                sw.Close();
            }

            string output_header = Path.Combine(Settings.OutputPath, OutputFileHeader);
            string output_cpp = Path.Combine(Settings.OutputPath, OutputFileCpp);
            string output_header_compat = Path.Combine(Settings.OutputPath, OutputFileHeaderCompat);
            string output_header_enums = Path.Combine(Settings.OutputPath, OutputFileHeaderEnums);

            Move(sw_h.File, output_header);
            Move(sw_cpp.File, output_cpp);
            Move(sw_h_compat.File, output_header_compat);
            Move(sw_h_enums.File, output_header_enums);
        }

        public FunctionCollection Process(EnumProcessor enum_processor, DelegateCollection delegates, EnumCollection enums,
            string apiname, string apiversion)
        {
            Console.WriteLine("Processing delegates.");
            var nav = new XPathDocument(Overrides).CreateNavigator();
            foreach (var version in apiversion.Split('|'))
            {
                // Translate each delegate:
                // 1st using the <replace> elements in overrides.xml
                // 2nd using the hardcoded rules in FuncProcessor (e.g. char* -> string)
                foreach (var signatures in delegates.Values)
                {
                    foreach (var d in signatures)
                    {
                        TranslateExtension(d);
                        TranslateReturnType(enum_processor, nav, d, enums, apiname, version);
                        TranslateParameters(enum_processor, nav, d, enums, apiname, version);
                        TranslateAttributes(nav, d, enums, apiname, version);
                    }
                }

                // Create overloads for backwards compatibility,
                // by resolving <overload> elements
                var overload_list = new List<Delegate>();
                foreach (var d in delegates.Values.Select(v => v.First()))
                {
                    var overload_element = GetFuncOverload(nav, d, apiname, apiversion);
                    if (overload_element != null)
                    {
                        var overload = new Delegate(d);
                        ApplyParameterReplacement(overload, overload_element);
                        ApplyReturnTypeReplacement(overload, overload_element);
                        overload_list.Add(overload);
                    }
                }
                foreach (var overload in overload_list)
                {
                    delegates.Add(overload);
                }
            }

            Console.WriteLine("Generating convenience overloads.");
            delegates.AddRange(CreateConvenienceOverloads(delegates));

            Console.WriteLine("Generating wrappers.");
            var wrappers = CreateWrappers(delegates, enums);

            Console.WriteLine("Generating CLS compliant overloads.");
            wrappers = CreateCLSCompliantWrappers(wrappers, enums);

            Console.WriteLine("Removing non-CLS compliant duplicates.");
            wrappers = MarkCLSCompliance(wrappers);

            Console.WriteLine("Removing overloaded delegates.");
            RemoveOverloadedDelegates(delegates, wrappers);

            return wrappers;
        }

 public frmMinimumCreditLimitManagerUI(decimal decimal1, EnumCollection.eProgramAction action1, List<int> list1)
 {
     this._decMininmumCreditLimit = 500M;
     this._objActionTaken = EnumCollection.eProgramAction.SwitchNextAccount;
     this._objAvailableActionList = new List<int>();
     this._decMininmumCreditLimit = decimal1;
     this._objActionTaken = action1;
     this._objAvailableActionList = list1;
 }

 internal frmPerMatchLimitManagerUI(int num1, EnumCollection.ePerMatchLimitType type1, decimal decimal1, decimal decimal2)
 {
     this._intLimitMethod = 1;
     this._objPerMatchLimitType = EnumCollection.ePerMatchLimitType.ByAmount;
     this._dclAmountLimit = new decimal();
     this._intCountLimit = 0;
     this._intLimitMethod = num1;
     this._objPerMatchLimitType = type1;
     this._dclAmountLimit = decimal1;
     this._intCountLimit = Convert.ToInt32(decimal2);
 }