From 576ee9b8b9be135d131d38b3c31a73697372fc7b Mon Sep 17 00:00:00 2001 From: Patrick Kitchens Date: Thu, 26 Apr 2018 00:58:00 -0500 Subject: [PATCH 01/13] OAuth implemented. Data is ? --- MoCha/Assets/Scenes/Main.unity | Bin 51304 -> 53688 bytes MoCha/Assets/Scripts/CustomAndroidPlugin.cs | 23 + .../Scripts/CustomAndroidPlugin.cs.meta | 13 + MoCha/Assets/Scripts/FitBitAPI.cs | 563 +++++++++ MoCha/Assets/Scripts/FitBitAPI.cs.meta | 13 + MoCha/Assets/Scripts/FitbitCaller.cs | 15 + MoCha/Assets/Scripts/FitbitCaller.cs.meta | 13 + MoCha/Assets/Scripts/FitbitData.cs | 54 + MoCha/Assets/Scripts/FitbitData.cs.meta | 13 + MoCha/Assets/Scripts/JSONObject.cs | 1017 +++++++++++++++++ MoCha/Assets/Scripts/JSONObject.cs.meta | 13 + MoCha/Assets/Scripts/OAuth2AccessToken.cs | 10 + .../Assets/Scripts/OAuth2AccessToken.cs.meta | 13 + MoCha/ProjectSettings/ProjectSettings.asset | Bin 55939 -> 56395 bytes 14 files changed, 1760 insertions(+) create mode 100644 MoCha/Assets/Scripts/CustomAndroidPlugin.cs create mode 100644 MoCha/Assets/Scripts/CustomAndroidPlugin.cs.meta create mode 100644 MoCha/Assets/Scripts/FitBitAPI.cs create mode 100644 MoCha/Assets/Scripts/FitBitAPI.cs.meta create mode 100644 MoCha/Assets/Scripts/FitbitCaller.cs create mode 100644 MoCha/Assets/Scripts/FitbitCaller.cs.meta create mode 100644 MoCha/Assets/Scripts/FitbitData.cs create mode 100644 MoCha/Assets/Scripts/FitbitData.cs.meta create mode 100644 MoCha/Assets/Scripts/JSONObject.cs create mode 100644 MoCha/Assets/Scripts/JSONObject.cs.meta create mode 100644 MoCha/Assets/Scripts/OAuth2AccessToken.cs create mode 100644 MoCha/Assets/Scripts/OAuth2AccessToken.cs.meta diff --git a/MoCha/Assets/Scenes/Main.unity b/MoCha/Assets/Scenes/Main.unity index 4653ae1b6e8fb26c5583435aa7083105930eb756..1cef1c2cb4c2a6dc7a4a29afd11485808ca1f395 100644 GIT binary patch delta 5469 zcmc&&dsI}%8K28@1;iD>C&KcQm+~~CCz^n6fJQ7dK8k4!P$h^#USg1>x{IQaYE&3N zlh%k4P!ko*O)3hCC|29XRNK>NQ)BcTO-PSc6SZoi(%*OQT-lAAmh_+A!@PdqH#6UB zzL}+GqkY?U`yj@ee$3dJHpbXs^b66ln5gKuh}ekem!jFj-rioxe_v3#B$@dNX_#b| z>!oam5oRVaI~HNj%r`JWhZ2Y)F*EmcDz!lk6VyhhNE_5~f_l|ygAM9?H+xOG|PK^7+Gn-$HJi z&W6Ef$i+cT_Wyxl2WW;cvO>A3OTHI2=6gd2t64GgVsi+Ok9F2}Ro*YWb-86q$+2j= zF7xy@zAOBd{_dzO5*kql{>})J;%tO^3Y?VlH3jCNh;&oTV&)Ck2w)LC*yv{jf#0;WanRWk34p%A?uLyJ1cJ|#Kv#Mnyozt5(RtRR=0LL@$P zf@L%#r#yCsPED{pLmG$08Irx?eC#a3R%0;;2~#E|*`SJ~Bk!Ixjy&8_OA64LZK&1p z8?{arQ|P>q$`*U_sJgLo<&=?X0&q~wt+5Rg`yPDCGM#DE(SrKy)0Rfps0Kl;u}P&9 zgM%l3`m~Q_9t{Uf@@bi8u#sGnU?hzwYrJZlgWee$%U>BUQ;dF`sHxkTsN;i@EY+ox z^j&pRljc|$MB^B!%EJ#Q{TXZiSC8Y69G6R?_{-?`F zzWw4u2T8|o&Hq1G)V&(&zRB>PO`!=cKpvcDJO7$pMFP$KkzFcB! zW22ysU22P(q*CRQrJvgh))&O&yizsNt+*gX7+1uH z{k>6-%igPSzWbSmtfF8-)edO@zfjdLnUuUReeLfhS3Y!Izh}s+)>l~GQQF%`OWAb7 zZ9c8|I$t9{RXr7o>1*ihhtzZ;jrY`~NkR6X+`aojL3$I9{j&FF#V zGjuK`X|3lx~6D1*R$2lyMsA!Gukq*6U(&vjQ@97Z_QFT(Co68=-0%#$^7T0=o!| zei;ox*(I>yP*vOHJ%LpLGr~rm;QQ!>TacL1R`B-3?P&EW& z3d%nUtP0p>jOm5sf8k*$8fJj1WoXF?0Rn3PHXiGd6$1r!4q9pJnSumJYH15j)$N)H zezqByX4Yu}(?eCV!UzT?g*?En5OZBPaF$CVwr)A z6``d~;skaMm}csU0xLwkkCjyGOcGcF@-{4OQlh$g;E#%F!IJ=2iv?>0mKNN16uH29 zfRQFpoYe|!B39FmVx7PWfst}J_H3oDP}$=mFwLE-bn{g(9tWrcOytj+nX8weQGN$& z(a#08EUZtvT7l`q`+~JjV1}`MapcZl|8?rTi)Ag!qK>HdwmttR{7a{o`d@rI1#2=! z{j}QZ8Cw68bMJFnKkjAMSE!E+$+UHxE&5)3^p+_7yI0b`IIwJ4;-M4O-)s*vl=7r4 zF?!vazc?KZJU^}Bc+L!|yizYO*^*!<>EsW$y4XA7{$PwBc_)P5c-w*ZymOc9x4Ln| z5nYIusX>2~$*GSt#u9T&ex6%0Eh{fCyO?i0Y;>UX&lfcN^VXgI_89O>4MTWDmp?ab z*WoqLwLJj!gSKGq)~H8sbYmRq#Ro$8^2R~vy`hXhI}pHo8a;_q8Nbo!%V#wWC(fow z)LHGpyt|3$13M!9ke->r)qq<4$iWRccgTp!H-LvWCrJ)+QS)ndcwSuF`8OvW2%iRX zX=@lS+@+Uw?@qLn9C^a-A(9(k{+sQ1O8MQ0`yF^n zOB%2(Ey1Xdx3rL%BDDladuj=i`pA83+R`N@1&b5%7ZexdE=bE;nvh6{82p;pwliEVX`LlOir?+~RUwZ$#0zuWE!436WC$1q!-(eW!gofh#tx_bz>?|cGsPwK2BxnXk2Q!YCiE=gYS-73EE ln2twvdk&y?fXmr{$vR%%9ZsmElgqn5|BkMTBhyak{tX#2!Ug~U delta 4778 zcmc&&Yfx3!72fA^@8t@LSHOT#;36Q3ycN+#D;NUkgoq)@po0T86#efhQb~A_V!{O9$XaN$wGQ+yLAd$-QmgJpgyI~FG(?9|)1qkV*y>NKN2?~u3E$Bb2XBhUz(wL!qk~_dF+m#! zwPJ0=#$Bbq_Pg3RKIsR4^lh#>PZME2 z`=mGOj*wsr-LJG$eP~od-v%4Y#$q|F;8Da4me^lo_4(@z#S$aJ4 zQgr+c;DvG(r-py5jd8ccqtwe|pHe6>{L=UBA2OGv)yiMKx;T zxbLk8=<6^31@*@7(emb@Rrn0J$$7JB?g~1bup4UQ5;<=fiC=1x_I{E9QgZGj{Vdq} zaf2lH=A<~f_N*5LPWC|=Mo!M)GxmHEtKF7lF7-GpUqcyp?`+ZbFU!@je$3=cPO!^;J;%;`0_ zT*#1HqaxbbcnUWR6vT`;)Aq_T#LKbX4<_d#B4?k*j(vHx^q zHk;$F5HRN%%vR0`@Dd_x@v3F%KQ1gG_vnd~y~{?;bM_Bv*B$DkS+NRAR}o&+Tj~eR zuRhVN?UA>Z(GclTtaSKCbI(~cwpTy)<2suXpB!lM({iy_POn9=(?6dcTxmLJMeaB) zEWIVy=FZiV=Go5&?itu1@?W6);ONIqls?>EptpC=$0TqjZvt1{jeKK2JMtYAQeZa~ zDhF@gQ{IOBg3nD7|I=qdZCZ5Ss(4c4lK*2qYM=W+Pp00@jQviR+1at;0}o{gWt9xp z#rI!)M$1oswPSR(6jRC{mxZOA^VOyLaqBNBzbDkBNp`cOYFo3-f(1L*@v@`q23nRT z4Ro(#13~L~Si7eaC|C?mVtI=pCS}}-qYD(pHy$$Fe0pk*2^sR5* z9cV{L8tvLQ3+cY1-6y`-hYe6qR%I&@VLnvQ)co%9pC9_<@DsmUmHH4ezZZ}Bx{|3~ zS4w9_LBSxt4iuIWO+g3DmmH&+%l=CR2hyi&TdfGRF!yqO+xf2B?^?13B**5|nOJdo; z5SQ@5)AD*+Cgs4WS zYcaCn_B{egWfv3P_!9yF(^Lt?qWsz7sTjlFSy0tV3o%+MDmu_A;&8T$D4 z5H7J3WeCeq7$Lze=;SRPIBOB?KSP!tRpdZHb7m2M2E<>dQ;1d5*f}O#AMe~(Udm&gN1s|?W z7+K*RiM0V^@A;$iH;Dzh^tF5k{JX@q1Iqyowc@VCx`1f`!@ijE8{6|3M0uzX#TeO0 zvcw!X7geA+GgBp24J=v~(lm*6;{Ir)x?w8UN?(n|TM8Md-2*erS zv?3r;DFv4SGmg_9iB$tDf(%Zi*z73Mj5yJpjs4sru_9oNkYT4^%Xw)P1`!|G*B3}) zCn81SzoV;^U<$%83TcnTvT>-4=!VkeH|IX~_W1>$;J*V8IJQ51Gb4&k@I1S+BFmV! zdp>y5m?uBy{UXn8c)He}=BeyKHTM$f1XA!}VA=%Bhd zyc=30sicni3oploI$+=B?P52yAG)TfUV4|^(|(@x+qw+8_trz|l(&~ya78*)f6ZnG z>ngp`9!W(kKOs^=S~S`;hws(y67&WElx@5ObZ_(BHtoH?Qlr9D3@!+Ye}iI7P> zdrlcfU!TnZl65W;@73o{t9kD{rGVM+?l+1;b?+^upEMp(tZHb}KB-snq4wq)Ww=^= zAzx9Pbmd|O{`^aQYb3?C1cT0MNyeK~;zUaL&FOF=9W(LfR4@`kt(RPw1=WSn9VF37 z8(POuLTiAWEta!Mpc`5r!MnRP+2%yNZo1eKLYbHSfgy1txaFG@=Tr|}K45VedrzC% z{V1m`2{F9VhU=Ujx3Bt(4<{;$AF{ZGx;}D{yWQXB^=a62J6&l{R_yAP_M6{|SIc5` Gr{iDaH|x^? diff --git a/MoCha/Assets/Scripts/CustomAndroidPlugin.cs b/MoCha/Assets/Scripts/CustomAndroidPlugin.cs new file mode 100644 index 0000000..a040bd8 --- /dev/null +++ b/MoCha/Assets/Scripts/CustomAndroidPlugin.cs @@ -0,0 +1,23 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using Assets.Scripts.Fitbit; + + +namespace Assets.Scripts +{ + public class CustomAndroidPlugin : MonoBehaviour + { + + public GameObject Manager; + + public void PassReturnCode(string value) + { + Manager.GetComponent().SetReturnCodeFromAndroid(value); + + } + + } + + +} diff --git a/MoCha/Assets/Scripts/CustomAndroidPlugin.cs.meta b/MoCha/Assets/Scripts/CustomAndroidPlugin.cs.meta new file mode 100644 index 0000000..a23005d --- /dev/null +++ b/MoCha/Assets/Scripts/CustomAndroidPlugin.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 80685d60eb42cd340a5c76d410187801 +timeCreated: 1524716619 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/MoCha/Assets/Scripts/FitBitAPI.cs b/MoCha/Assets/Scripts/FitBitAPI.cs new file mode 100644 index 0000000..4dfdbca --- /dev/null +++ b/MoCha/Assets/Scripts/FitBitAPI.cs @@ -0,0 +1,563 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; +using System.Xml; +using System.Xml.Linq; +using Newtonsoft.Json; +using UnityEngine; + +namespace Assets.Scripts.Fitbit +{ + + public class FitBitAPI : MonoBehaviour + { + + private const string _consumerSecret = "69307b9f332caf9946ef4e23cabde2e4"; + private const string _clientId = "22CX4L"; + private const string _callbackURL = "http://localhost/callback"; + //If you're making an app for Android, fill in your custom scheme here from Fitbit + //if you don't know how to do the callback through a native browser on a mobile device + //http://technicalartistry.blogspot.ca/2016/01/fitbit-unity-oauth-2-and-native.html + //can probably help :) + private const string CustomAndroidScheme = "mochaapp://TheCallback"; + + private const string _tokenUrl = "https://api.fitbit.com/oauth2/token"; + private const string _baseGetUrl = "https://api.fitbit.com/1/user/-/"; + private const string _profileUrl = _baseGetUrl + "profile.json/"; + private const string _activityUrl = _baseGetUrl + "activities/"; + + private string _distanceUrl = _activityUrl + "distance/date/" + _currentDateTime + "/1d.json"; + + private string _stepsUrl = _activityUrl + "steps/date/" + _currentDateTime + "/1d.json"; + + private string _caloriesUrl = _activityUrl + "calories/date/" + _currentDateTime + "/1d.json"; + + private string _sleepUrl = _baseGetUrl + "sleep/minutesAsleep/date/" + _currentDateTime + "/" + _currentDateTime + ".json"; + + private static string _currentDateTime = GetCurrentDate(); + + private string _returnCode; + private WWW _wwwRequest; + private bool _bGotTheData = false; + private bool _bFirstFire = true; + + private OAuth2AccessToken _oAuth2 = new OAuth2AccessToken(); + public FitbitData _fitbitData = new FitbitData(); + + //Debug String for Android + private string _statusMessage; + + private string CallBackUrl + { + get + { + //determine which platform we're running on and use the appropriate url + if (Application.platform == RuntimePlatform.WindowsEditor) + return WWW.EscapeURL(_callbackURL); + else if (Application.platform == RuntimePlatform.Android) + { + return WWW.EscapeURL(CustomAndroidScheme); + } + else + { + return WWW.EscapeURL(CustomAndroidScheme); + } + } + } + + public void Start() + { + DontDestroyOnLoad(this); + } + + private void OnGUI() + { + if (!_bGotTheData && !string.IsNullOrEmpty(_statusMessage) && _bFirstFire) + { + _bFirstFire = false; + } + GUI.Label(new Rect(10, 10, 500, 500), "Number Steps: " + _fitbitData.CurrentSteps); + + GUI.Label(new Rect(10, 20, 500, 500), "Calories: " + _fitbitData.CurrentCalories); + GUI.Label(new Rect(10, 40, 500, 500), "Distance Walked: " + _fitbitData.CurrentDistance); + GUI.Label(new Rect(10, 60, 500, 500), "Return Code " + _returnCode); + } + + public void LoginToFitbit() + { + //we'll check to see if we have the RefreshToken in PlayerPrefs or not. + //if we do, then we'll use the RefreshToken to get the data + //if not then we will just do the regular ask user to login to get data + //then save the tokens correctly. + + if (PlayerPrefs.HasKey("FitbitRefreshToken")) + { + UseRefreshToken(); + } + else + { + UserAcceptOrDeny(); + } + + } + public void UserAcceptOrDeny() + { + //we don't have a refresh token so we gotta go through the whole auth process. + var url = + "https://www.fitbit.com/oauth2/authorize?response_type=code&client_id=" + _clientId + "&redirect_uri=" + + CallBackUrl + + "&scope=activity%20nutrition%20heartrate%20location%20profile%20sleep%20weight%20social"; + Application.OpenURL(url); + // print(url); +#if UNITY_EDITOR +#endif + } + + public void ClearRefreshCode() + { + PlayerPrefs.DeleteKey("FitbitRefreshToken"); + Debug.Log("Refresh Token has been CLEARED!"); + } + + private void UseReturnCode() + { + Debug.Log("return code isn't empty"); + //not empty means we put a code in + var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(_clientId + ":" + _consumerSecret); + var encoded = Convert.ToBase64String(plainTextBytes); + + var form = new WWWForm(); + form.AddField("client_id", _clientId); + form.AddField("grant_type", "authorization_code"); + form.AddField("redirect_uri", WWW.UnEscapeURL(CallBackUrl)); + form.AddField("code", _returnCode); + + var headers = form.headers; + headers["Authorization"] = "Basic " + encoded; + + _wwwRequest = new WWW(_tokenUrl, form.data, headers); + StartCoroutine(WaitForAccess(_wwwRequest)); + + //DIRTY DIRTY HACK + while (!_wwwRequest.isDone) + { + } + + Debug.Log("Token: " + _wwwRequest.text); + Debug.Log("parsing token"); + + var parsed = new JSONObject(_wwwRequest.text); + ParseAccessToken(parsed); + Debug.Log("\nParsed Token: " + _oAuth2.Token); + + //now that we have the Auth Token, Lets use it and get data. + GetAllData(); + Debug.Log("Steps from Fitbit: " + _fitbitData.CurrentSteps); + _bGotTheData = true; + } + + public void UseRefreshToken() + { + Debug.Log("Using Refresh Token"); + var plainTextBytes = Encoding.UTF8.GetBytes(_clientId + ":" + _consumerSecret); + var encoded = Convert.ToBase64String(plainTextBytes); + + var form = new WWWForm(); + form.AddField("grant_type", "refresh_token"); + form.AddField("refresh_token", PlayerPrefs.GetString("FitbitRefreshToken")); + + var headers = form.headers; + headers["Authorization"] = "Basic " + encoded; + + _wwwRequest = new WWW(_tokenUrl, form.data, headers); + StartCoroutine(WaitForAccess(_wwwRequest)); + //DIRTY DIRTY HACK + while (!_wwwRequest.isDone) + { + } + + Debug.Log("RefreshToken wwwText: " + _wwwRequest.text); + //check to see if it's errored or not + //we have an error and thus should just redo the Auth. + if (!String.IsNullOrEmpty(_wwwRequest.error)) + { + PlayerPrefs.DeleteKey("FitbitRefreshToken"); + UserAcceptOrDeny(); + UseReturnCode(); + GetAllData(); + } + else + { + Debug.Log("Using the Auth Token (UseRefreshToken)"); + //no errors so parse the accessToken and update everything :) + var parsed = new JSONObject(_wwwRequest.text); + ParseAccessToken(parsed); + GetAllData(); + } + } + + public void SetReturnCodeFromAndroid(string code) + { + if (string.IsNullOrEmpty(code)) + return; + //we passed the full URL so we'll have to extract the + //We will add 6 to the string lenght to account for "?code=" + _returnCode = code.Substring(CustomAndroidScheme.Length + 6); + Debug.Log("Return Code is: " + _returnCode); + + UseReturnCode(); + } + + public void SetReturnCode(string code) + { + if (string.IsNullOrEmpty(code)) + return; + + _returnCode = code; + UseReturnCode(); + } + + + + + public void GetAllData() + { + GetProfileData(); + GetAllRelevantData(); + BuildProfile(); + + //make sure the loading screen is open and change message + _fitbitData.LastSyncTime = DateTime.Now.ToUniversalTime(); + Debug.Log("LastSyncTime: " + DateTime.Now.ToUniversalTime().ToString("g")); + } + + private void GetAllRelevantData() + { + GetSteps(); + GetDistance(); + GetCalories(); + GetSleep(); + } + + #region GetData + private void GetProfileData() + { + + //time for Getting Dataz + var headers = new Dictionary(); + headers["Authorization"] = "Bearer " + _oAuth2.Token; + + _wwwRequest = new WWW(_profileUrl, null, headers); + Debug.Log("Doing GET Request"); + StartCoroutine(WaitForAccess(_wwwRequest)); + + //DIRTY DIRTY HACK + while (!_wwwRequest.isDone) + { + } + + ParseProfileData(_wwwRequest.text); + + } + + private void GetCalories() + { + //time for Getting Dataz + var headers = new Dictionary(); + headers["Authorization"] = "Bearer " + _oAuth2.Token; + + Debug.Log("Calories URL is: " + _caloriesUrl); + _wwwRequest = new WWW(_caloriesUrl, null, headers); + Debug.Log("Doing Calories GET Request"); + StartCoroutine(WaitForAccess(_wwwRequest)); + + //DIRTY DIRTY HACK + while (!_wwwRequest.isDone) + { + } + ParseCaloriesData(_wwwRequest.text); + } + + private void GetDistance() + { + //time for Getting Dataz + var headers = new Dictionary(); + headers["Authorization"] = "Bearer " + _oAuth2.Token; + + Debug.Log("Distance URL is: " + _distanceUrl); + _wwwRequest = new WWW(_distanceUrl, null, headers); + Debug.Log("Doing Distance GET Request"); + StartCoroutine(WaitForAccess(_wwwRequest)); + + //DIRTY DIRTY HACK + while (!_wwwRequest.isDone) + { + } + + ParseDistanceData(_wwwRequest.text); + } + + private void GetSteps() + { + //time for Getting Dataz + var headers = new Dictionary(); + headers["Authorization"] = "Bearer " + _oAuth2.Token; + + Debug.Log("Steps URL is: " + _stepsUrl); + _wwwRequest = new WWW(_stepsUrl, null, headers); + Debug.Log("Doing Steps GET Request"); + StartCoroutine(WaitForAccess(_wwwRequest)); + + //DIRTY DIRTY HACK + while (!_wwwRequest.isDone) + { + } + + ParseStepsData(_wwwRequest.text); + } + + private void GetSleep() + { + //time for Getting Dataz + var headers = new Dictionary(); + headers["Authorization"] = "Bearer " + _oAuth2.Token; + + Debug.Log("Sleep URL is: " + _sleepUrl); + _wwwRequest = new WWW(_sleepUrl, null, headers); + Debug.Log("Doing Sleep GET Request"); + StartCoroutine(WaitForAccess(_wwwRequest)); + + //DIRTY DIRTY HACK + while (!_wwwRequest.isDone) + { + } + + ParseSleepData(_wwwRequest.text); + } + + private void BuildProfile() + { + var imageWWW = new WWW(_fitbitData.ProfileData["avatar"]); + //DIRTY DIRTY HACK + while (!imageWWW.isDone) + { + } + + Debug.Log(_fitbitData.RawProfileData["fullName"]); + + //we should check to see if there is "data" already + if (_fitbitData.ProfileData.Count != 0) + { + foreach (KeyValuePair kvp in _fitbitData.ProfileData) + { + if (kvp.Key == "avatar") + continue; + + //put a space between the camelCase + var tempKey = Regex.Replace(kvp.Key, "(\\B[A-Z])", " $1"); + //then capitalize the first letter + UppercaseFirst(tempKey); + } + } + + _bGotTheData = true; + } + #endregion + + #region Parsing + private void ParseAccessToken(JSONObject parsed) + { + var dict = parsed.ToDictionary(); + foreach (KeyValuePair kvp in dict) + { + if (kvp.Key == "access_token") + { + _oAuth2.Token = kvp.Value; + PlayerPrefs.SetString("FitbitAccessToken", kvp.Value); + } + else if (kvp.Key == "expires_in") + { + var num = 0; + Int32.TryParse(kvp.Value, out num); + _oAuth2.ExpiresIn = num; + + } + else if (kvp.Key == "refresh_token") + { + _oAuth2.RefreshToken = kvp.Value; + Debug.Log("REFRESH TOKEN: " + kvp.Value); + PlayerPrefs.SetString("FitbitRefreshToken", kvp.Value); + Debug.Log("Token We Just Store: " + PlayerPrefs.GetString("FitbitRefreshToken")); + } + else if (kvp.Key == "token_type") + { + _oAuth2.TokenType = kvp.Value; + PlayerPrefs.SetString("FitbitTokenType", kvp.Value); + } + } + } + + private void ParseProfileData(string data) + { + Debug.Log("inserting json data into fitbitData.RawProfileData"); + //Debug.LogWarning(data); + XmlDocument xmldoc = JsonConvert.DeserializeXmlNode(data); + + var doc = XDocument.Parse(xmldoc.InnerXml); + + + doc.Descendants("topBadges").Remove(); + foreach (XElement xElement in doc.Descendants()) + { + //Debug.Log(xElement.Name.LocalName + ": Value:" + xElement.Value);V + if (!_fitbitData.RawProfileData.ContainsKey(xElement.Name.LocalName)) + _fitbitData.RawProfileData.Add(xElement.Name.LocalName, xElement.Value); + else + { + //Debug.LogWarning("Key already found in RawProfileData: " + xElement.Name.LocalName); + //if the key is already in the dict, we will just update the value for consistency. + _fitbitData.RawProfileData[xElement.Name.LocalName] = xElement.Value; + } + + if (_fitbitData.ProfileData.ContainsKey(xElement.Name.LocalName)) + { + _fitbitData.ProfileData[xElement.Name.LocalName] = xElement.Value; + } + } + } + + private void ParseStepsData(string data) + { + //convert the json to xml cause json blows hard. + XmlDocument json = JsonConvert.DeserializeXmlNode(data); + + XDocument doc = XDocument.Parse(json.InnerXml); + var root = doc.Descendants("value").FirstOrDefault(); + _fitbitData.CurrentSteps = ToInt(root.Value); + + Debug.Log("Steps from Fitbit: " + _fitbitData.CurrentSteps); + } + + private void ParseDistanceData(string data) + { + XmlDocument json = JsonConvert.DeserializeXmlNode(data); + + XDocument doc = XDocument.Parse(json.InnerXml); + var root = doc.Descendants("value").FirstOrDefault().Value; + //trim the value + if (root.Length > 4) + root = root.Substring(0, 4); + + _fitbitData.CurrentDistance = ToDouble(root); + + Debug.Log("Distance from Fitbit is:" + _fitbitData.CurrentDistance); + } + + private void ParseCaloriesData(string data) + { + XmlDocument json = JsonConvert.DeserializeXmlNode(data); + + var doc = XDocument.Parse(json.InnerXml); + var calories = doc.Descendants("value").FirstOrDefault().Value; + + _fitbitData.CurrentCalories = ToInt(calories); + } + + private void ParseSleepData(string data) + { + Debug.Log(data); + XmlDocument json = JsonConvert.DeserializeXmlNode(data); + + var doc = XDocument.Parse(json.InnerXml); + var sleepTimeTotal = doc.Descendants("value").FirstOrDefault().Value; + Debug.Log("Minutes asleep for: " + sleepTimeTotal); + + _fitbitData.CurrentSleep = ToInt(sleepTimeTotal); + } + + + #endregion + + static string UppercaseFirst(string s) + { + // Check for empty string. + if (string.IsNullOrEmpty(s)) + { + return string.Empty; + } + // Return char and concat substring. + return char.ToUpper(s[0]) + s.Substring(1); + } + + IEnumerator WaitForAccess(WWW www) + { + Debug.Log("waiting for access\n"); + yield return www; + Debug.Log("Past the Yield \n"); + // check for errors + if (www.error == null) + { + Debug.Log("no error \n"); + Debug.Log("Steps from Fitbit: " + _fitbitData.CurrentSteps); + Debug.Log(www.text); + Debug.Log("Steps from Fitbit: " + _fitbitData.CurrentSteps); + //Debug.Log("WWW Ok!: " + www.text); + // _accessToken = www.responseHeaders["access_token"]; + } + if (www.error != null) + { + Debug.Log("\n Error" + www.error); + Debug.Log(www.error); + } + Debug.Log("end of WaitForAccess \n"); + + } + + //just a utility function to get the correct date format for activity calls that require one + public static string GetCurrentDate() + { + var date = ""; + date += DateTime.Now.Year; + if (DateTime.Now.Month < 10) + { + date += "-" + "0" + DateTime.Now.Month; + } + else + { + date += "-" + DateTime.Now.Month; + } + + if (DateTime.Now.Day < 10) + { + date += "-" + "0" + DateTime.Now.Day; + } + else + { + date += "-" + DateTime.Now.Day; + } + //date += "-" + 15; + return date; + } + + + + private int ToInt(string thing) + { + var temp = 0; + Int32.TryParse(thing, out temp); + return temp; + } + + private double ToDouble(string thing) + { + var temp = 0.0; + Double.TryParse(thing, out temp); + return temp; + } + + } + +} diff --git a/MoCha/Assets/Scripts/FitBitAPI.cs.meta b/MoCha/Assets/Scripts/FitBitAPI.cs.meta new file mode 100644 index 0000000..8514324 --- /dev/null +++ b/MoCha/Assets/Scripts/FitBitAPI.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: aa5e856e9b878764db7c192f3aa20277 +timeCreated: 1524716713 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/MoCha/Assets/Scripts/FitbitCaller.cs b/MoCha/Assets/Scripts/FitbitCaller.cs new file mode 100644 index 0000000..0dad878 --- /dev/null +++ b/MoCha/Assets/Scripts/FitbitCaller.cs @@ -0,0 +1,15 @@ +using UnityEngine; +using System.Collections; + +public class FitbitCaller : MonoBehaviour { + + // Use this for initialization + void Start () { + + } + + // Update is called once per frame + void Update () { + + } +} diff --git a/MoCha/Assets/Scripts/FitbitCaller.cs.meta b/MoCha/Assets/Scripts/FitbitCaller.cs.meta new file mode 100644 index 0000000..1dc151a --- /dev/null +++ b/MoCha/Assets/Scripts/FitbitCaller.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 36444c03eedb84147a326a329de30d0e +timeCreated: 1524716713 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/MoCha/Assets/Scripts/FitbitData.cs b/MoCha/Assets/Scripts/FitbitData.cs new file mode 100644 index 0000000..2d7e88b --- /dev/null +++ b/MoCha/Assets/Scripts/FitbitData.cs @@ -0,0 +1,54 @@ +using System; +using System.Collections.Generic; + +namespace Assets.Scripts.Fitbit +{ + /// + /// Holder class for Fitbit pulled Data. + /// + public class FitbitData + { + public string CurrentTab = "Profile"; + + public Dictionary RawProfileData; + public Dictionary ProfileData; + + public int CurrentSteps; + public int LastSteps; + + public double CurrentDistance; + public double LastDistance; + + public int CurrentCalories; + public int LastCalories; + + public int CurrentSleep; + public int LastSleep; + + public DateTime LastSyncTime; + + public enum summary + { + activityCalories,caloriesBMR,caloriesOut,distances,activityDistance,distance, + elevation,fairlyActiveMinutes,floors,lightlyActiveMinutes,marginalCalories,sedentaryMinutes, + steps,veryActiveMinutes + } + + public FitbitData() + { + RawProfileData =new Dictionary(); + ProfileData = new Dictionary(); + + //we will build the Profile Data Keys that we want so we can compare them later + //to decide what we keep and what we don't when we get the actual data + ProfileData.Add("age",""); + ProfileData.Add("avatar",""); + ProfileData.Add("averageDailySteps",""); + ProfileData.Add("city",""); + ProfileData.Add("country",""); + ProfileData.Add("dateOfBirth",""); + ProfileData.Add("gender",""); + ProfileData.Add("memberSince",""); + } + } +} diff --git a/MoCha/Assets/Scripts/FitbitData.cs.meta b/MoCha/Assets/Scripts/FitbitData.cs.meta new file mode 100644 index 0000000..add5ba3 --- /dev/null +++ b/MoCha/Assets/Scripts/FitbitData.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 7a928c029cb14204588724261a513ec1 +timeCreated: 1524716713 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/MoCha/Assets/Scripts/JSONObject.cs b/MoCha/Assets/Scripts/JSONObject.cs new file mode 100644 index 0000000..c6ede39 --- /dev/null +++ b/MoCha/Assets/Scripts/JSONObject.cs @@ -0,0 +1,1017 @@ +#define PRETTY //Comment out when you no longer need to read JSON to disable pretty Print system-wide +//Using doubles will cause errors in VectorTemplates.cs; Unity speaks floats +#define USEFLOAT //Use floats for numbers instead of doubles (enable if you're getting too many significant digits in string output) +//#define POOLING //Currently using a build setting for this one (also it's experimental) + +using System.Diagnostics; +using UnityEngine; +using System.Collections; +using System.Collections.Generic; +using System.Text; +using Debug = UnityEngine.Debug; + +/* + * http://www.opensource.org/licenses/lgpl-2.1.php + * JSONObject class v.1.4.1 + * for use with Unity + * Copyright Matt Schoen 2010 - 2013 + */ + +public class JSONObject { +#if POOLING + const int MAX_POOL_SIZE = 10000; + public static Queue releaseQueue = new Queue(); +#endif + + const int MAX_DEPTH = 100; + const string INFINITY = "\"INFINITY\""; + const string NEGINFINITY = "\"NEGINFINITY\""; + const string NaN = "\"NaN\""; + public static readonly char[] WHITESPACE = { ' ', '\r', '\n', '\t', '\uFEFF', '\u0009' }; + public enum Type { NULL, STRING, NUMBER, OBJECT, ARRAY, BOOL, BAKED } + public bool isContainer { get { return (type == Type.ARRAY || type == Type.OBJECT); } } + public Type type = Type.NULL; + public int Count { + get { + if(list == null) + return -1; + return list.Count; + } + } + public List list; + public List keys; + public string str; +#if USEFLOAT + public float n; + public float f { + get { + return n; + } + } +#else + public double n; + public float f { + get { + return (float)n; + } + } +#endif + public bool b; + public delegate void AddJSONConents(JSONObject self); + + public static JSONObject nullJO { get { return Create(Type.NULL); } } //an empty, null object + public static JSONObject obj { get { return Create(Type.OBJECT); } } //an empty object + public static JSONObject arr { get { return Create(Type.ARRAY); } } //an empty array + + public JSONObject(Type t) { + type = t; + switch(t) { + case Type.ARRAY: + list = new List(); + break; + case Type.OBJECT: + list = new List(); + keys = new List(); + break; + } + } + public JSONObject(bool b) { + type = Type.BOOL; + this.b = b; + } +#if USEFLOAT + public JSONObject(float f) { + type = Type.NUMBER; + n = f; + } +#else + public JSONObject(double d) { + type = Type.NUMBER; + n = d; + } +#endif + public JSONObject(Dictionary dic) { + type = Type.OBJECT; + keys = new List(); + list = new List(); + //Not sure if it's worth removing the foreach here + foreach(KeyValuePair kvp in dic) { + keys.Add(kvp.Key); + list.Add(CreateStringObject(kvp.Value)); + } + } + public JSONObject(Dictionary dic) { + type = Type.OBJECT; + keys = new List(); + list = new List(); + //Not sure if it's worth removing the foreach here + foreach(KeyValuePair kvp in dic) { + keys.Add(kvp.Key); + list.Add(kvp.Value); + } + } + public JSONObject(AddJSONConents content) { + content.Invoke(this); + } + public JSONObject(JSONObject[] objs) { + type = Type.ARRAY; + list = new List(objs); + } + //Convenience function for creating a JSONObject containing a string. This is not part of the constructor so that malformed JSON data doesn't just turn into a string object + public static JSONObject StringObject(string val) { return CreateStringObject(val); } + public void Absorb(JSONObject obj) { + list.AddRange(obj.list); + keys.AddRange(obj.keys); + str = obj.str; + n = obj.n; + b = obj.b; + type = obj.type; + } + public static JSONObject Create() { +#if POOLING + JSONObject result = null; + while(result == null && releaseQueue.Count > 0) { + result = releaseQueue.Dequeue(); +#if DEV + //The following cases should NEVER HAPPEN (but they do...) + if(result == null) + Debug.Log("wtf " + releaseQueue.Count); + else if(result.list != null) + Debug.Log("wtflist " + result.list.Count); +#endif + } + if(result != null) + return result; +#endif + return new JSONObject(); + } + public static JSONObject Create(Type t) { + JSONObject obj = Create(); + obj.type = t; + switch(t) { + case Type.ARRAY: + obj.list = new List(); + break; + case Type.OBJECT: + obj.list = new List(); + obj.keys = new List(); + break; + } + return obj; + } + public static JSONObject Create(bool val) { + JSONObject obj = Create(); + obj.type = Type.BOOL; + obj.b = val; + return obj; + } + public static JSONObject Create(float val) { + JSONObject obj = Create(); + obj.type = Type.NUMBER; + obj.n = val; + return obj; + } + public static JSONObject Create(int val) { + JSONObject obj = Create(); + obj.type = Type.NUMBER; + obj.n = val; + return obj; + } + public static JSONObject CreateStringObject(string val) { + JSONObject obj = Create(); + obj.type = Type.STRING; + obj.str = val; + return obj; + } + public static JSONObject CreateBakedObject(string val) { + JSONObject bakedObject = Create(); + bakedObject.type = Type.BAKED; + bakedObject.str = val; + return bakedObject; + } + /// + /// Create a JSONObject by parsing string data + /// + /// The string to be parsed + /// The maximum depth for the parser to search. Set this to to 1 for the first level, + /// 2 for the first 2 levels, etc. It defaults to -2 because -1 is the depth value that is parsed (see below) + /// Whether to store levels beyond maxDepth in baked JSONObjects + /// Whether to be strict in the parsing. For example, non-strict parsing will successfully + /// parse "a string" into a string-type + /// + public static JSONObject Create(string val, int maxDepth = -2, bool storeExcessLevels = false, bool strict = false) { + JSONObject obj = Create(); + obj.Parse(val, maxDepth, storeExcessLevels, strict); + return obj; + } + public static JSONObject Create(AddJSONConents content) { + JSONObject obj = Create(); + content.Invoke(obj); + return obj; + } + public static JSONObject Create(Dictionary dic) { + JSONObject obj = Create(); + obj.type = Type.OBJECT; + obj.keys = new List(); + obj.list = new List(); + //Not sure if it's worth removing the foreach here + foreach(KeyValuePair kvp in dic) { + obj.keys.Add(kvp.Key); + obj.list.Add(CreateStringObject(kvp.Value)); + } + return obj; + } + public JSONObject() { } + #region PARSE + public JSONObject(string str, int maxDepth = -2, bool storeExcessLevels = false, bool strict = false) { //create a new JSONObject from a string (this will also create any children, and parse the whole string) + Parse(str, maxDepth, storeExcessLevels, strict); + } + void Parse(string str, int maxDepth = -2, bool storeExcessLevels = false, bool strict = false) { + if(!string.IsNullOrEmpty(str)) { + str = str.Trim(WHITESPACE); + if(strict) { + if(str[0] != '[' && str[0] != '{') { + type = Type.NULL; + Debug.LogWarning("Improper (strict) JSON formatting. First character must be [ or {"); + return; + } + } + if(str.Length > 0) { +#if UNITY_WP8 + if (str == "true") { + type = Type.BOOL; + b = true; + } else if (str == "false") { + type = Type.BOOL; + b = false; + } else if (str == "null") { + type = Type.NULL; +#else + if(string.Compare(str, "true", true) == 0) { + type = Type.BOOL; + b = true; + } else if(string.Compare(str, "false", true) == 0) { + type = Type.BOOL; + b = false; + } else if(string.Compare(str, "null", true) == 0) { + type = Type.NULL; +#endif +#if USEFLOAT + } else if(str == INFINITY) { + type = Type.NUMBER; + n = float.PositiveInfinity; + } else if(str == NEGINFINITY) { + type = Type.NUMBER; + n = float.NegativeInfinity; + } else if(str == NaN) { + type = Type.NUMBER; + n = float.NaN; +#else + } else if(str == INFINITY) { + type = Type.NUMBER; + n = double.PositiveInfinity; + } else if(str == NEGINFINITY) { + type = Type.NUMBER; + n = double.NegativeInfinity; + } else if(str == NaN) { + type = Type.NUMBER; + n = double.NaN; +#endif + } else if(str[0] == '"') { + type = Type.STRING; + this.str = str.Substring(1, str.Length - 2); + } else { + int tokenTmp = 1; + /* + * Checking for the following formatting (www.json.org) + * object - {"field1":value,"field2":value} + * array - [value,value,value] + * value - string - "string" + * - number - 0.0 + * - bool - true -or- false + * - null - null + */ + int offset = 0; + switch(str[offset]) { + case '{': + type = Type.OBJECT; + keys = new List(); + list = new List(); + break; + case '[': + type = Type.ARRAY; + list = new List(); + break; + default: + try { +#if USEFLOAT + n = System.Convert.ToSingle(str); +#else + n = System.Convert.ToDouble(str); +#endif + type = Type.NUMBER; + } catch(System.FormatException) { + type = Type.NULL; + Debug.LogWarning("improper JSON formatting:" + str); + } + return; + } + string propName = ""; + bool openQuote = false; + bool inProp = false; + int depth = 0; + while(++offset < str.Length) { + if(System.Array.IndexOf(WHITESPACE, str[offset]) > -1) + continue; + if(str[offset] == '\\') { + offset += 1; + continue; + } + if(str[offset] == '"') { + if(openQuote) { + if(!inProp && depth == 0 && type == Type.OBJECT) + propName = str.Substring(tokenTmp + 1, offset - tokenTmp - 1); + openQuote = false; + } else { + if(depth == 0 && type == Type.OBJECT) + tokenTmp = offset; + openQuote = true; + } + } + if(openQuote) + continue; + if(type == Type.OBJECT && depth == 0) { + if(str[offset] == ':') { + tokenTmp = offset + 1; + inProp = true; + } + } + + if(str[offset] == '[' || str[offset] == '{') { + depth++; + } else if(str[offset] == ']' || str[offset] == '}') { + depth--; + } + //if (encounter a ',' at top level) || a closing ]/} + if((str[offset] == ',' && depth == 0) || depth < 0) { + inProp = false; + string inner = str.Substring(tokenTmp, offset - tokenTmp).Trim(WHITESPACE); + if(inner.Length > 0) { + if(type == Type.OBJECT) + keys.Add(propName); + if(maxDepth != -1) //maxDepth of -1 is the end of the line + list.Add(Create(inner, (maxDepth < -1) ? -2 : maxDepth - 1)); + else if(storeExcessLevels) + list.Add(CreateBakedObject(inner)); + + } + tokenTmp = offset + 1; + } + } + } + } else type = Type.NULL; + } else type = Type.NULL; //If the string is missing, this is a null + //Profiler.EndSample(); + } + #endregion + public bool IsNumber { get { return type == Type.NUMBER; } } + public bool IsNull { get { return type == Type.NULL; } } + public bool IsString { get { return type == Type.STRING; } } + public bool IsBool { get { return type == Type.BOOL; } } + public bool IsArray { get { return type == Type.ARRAY; } } + public bool IsObject { get { return type == Type.OBJECT || type == Type.BAKED; } } + public void Add(bool val) { + Add(Create(val)); + } + public void Add(float val) { + Add(Create(val)); + } + public void Add(int val) { + Add(Create(val)); + } + public void Add(string str) { + Add(CreateStringObject(str)); + } + public void Add(AddJSONConents content) { + Add(Create(content)); + } + public void Add(JSONObject obj) { + if(obj) { //Don't do anything if the object is null + if(type != Type.ARRAY) { + type = Type.ARRAY; //Congratulations, son, you're an ARRAY now + if(list == null) + list = new List(); + } + list.Add(obj); + } + } + public void AddField(string name, bool val) { + AddField(name, Create(val)); + } + public void AddField(string name, float val) { + AddField(name, Create(val)); + } + public void AddField(string name, int val) { + AddField(name, Create(val)); + } + public void AddField(string name, AddJSONConents content) { + AddField(name, Create(content)); + } + public void AddField(string name, string val) { + AddField(name, CreateStringObject(val)); + } + public void AddField(string name, JSONObject obj) { + if(obj) { //Don't do anything if the object is null + if(type != Type.OBJECT) { + if(keys == null) + keys = new List(); + if(type == Type.ARRAY) { + for(int i = 0; i < list.Count; i++) + keys.Add(i + ""); + } else + if(list == null) + list = new List(); + type = Type.OBJECT; //Congratulations, son, you're an OBJECT now + } + keys.Add(name); + list.Add(obj); + } + } + public void SetField(string name, string val) { SetField(name, CreateStringObject(val)); } + public void SetField(string name, bool val) { SetField(name, Create(val)); } + public void SetField(string name, float val) { SetField(name, Create(val)); } + public void SetField(string name, int val) { SetField(name, Create(val)); } + public void SetField(string name, JSONObject obj) { + if(HasField(name)) { + list.Remove(this[name]); + keys.Remove(name); + } + AddField(name, obj); + } + public void RemoveField(string name) { + if(keys.IndexOf(name) > -1) { + list.RemoveAt(keys.IndexOf(name)); + keys.Remove(name); + } + } + public delegate void FieldNotFound(string name); + public delegate void GetFieldResponse(JSONObject obj); + public bool GetField(ref bool field, string name, bool fallback) { + if (GetField(ref field, name)) { return true; } + field = fallback; + return false; + } + public bool GetField(ref bool field, string name, FieldNotFound fail = null) { + if(type == Type.OBJECT) { + int index = keys.IndexOf(name); + if(index >= 0) { + field = list[index].b; + return true; + } + } + if(fail != null) fail.Invoke(name); + return false; + } +#if USEFLOAT + public bool GetField(ref float field, string name, float fallback) { +#else + public bool GetField(ref double field, string name, double fallback) { +#endif + if (GetField(ref field, name)) { return true; } + field = fallback; + return false; + } +#if USEFLOAT + public bool GetField(ref float field, string name, FieldNotFound fail = null) { +#else + public bool GetField(ref double field, string name, FieldNotFound fail = null) { +#endif + if(type == Type.OBJECT) { + int index = keys.IndexOf(name); + if(index >= 0) { + field = list[index].n; + return true; + } + } + if(fail != null) fail.Invoke(name); + return false; + } + public bool GetField(ref int field, string name, int fallback) { + if (GetField(ref field, name)) { return true; } + field = fallback; + return false; + } + public bool GetField(ref int field, string name, FieldNotFound fail = null) { + if (IsObject) { + int index = keys.IndexOf(name); + if(index >= 0) { + field = (int)list[index].n; + return true; + } + } + if(fail != null) fail.Invoke(name); + return false; + } + public bool GetField(ref uint field, string name, uint fallback) { + if (GetField(ref field, name)) { return true; } + field = fallback; + return false; + } + public bool GetField(ref uint field, string name, FieldNotFound fail = null) { + if (IsObject) { + int index = keys.IndexOf(name); + if(index >= 0) { + field = (uint)list[index].n; + return true; + } + } + if(fail != null) fail.Invoke(name); + return false; + } + public bool GetField(ref string field, string name, string fallback) { + if (GetField(ref field, name)) { return true; } + field = fallback; + return false; + } + public bool GetField(ref string field, string name, FieldNotFound fail = null) { + if (IsObject) { + int index = keys.IndexOf(name); + if(index >= 0) { + field = list[index].str; + return true; + } + } + if(fail != null) fail.Invoke(name); + return false; + } + public void GetField(string name, GetFieldResponse response, FieldNotFound fail = null) { + if(response != null && IsObject) { + int index = keys.IndexOf(name); + if(index >= 0) { + response.Invoke(list[index]); + return; + } + } + if(fail != null) fail.Invoke(name); + } + public JSONObject GetField(string name) { + if (IsObject) + for(int i = 0; i < keys.Count; i++) + if(keys[i] == name) + return list[i]; + return null; + } + public bool HasFields(string[] names) { + if (!IsObject) + return false; + for(int i = 0; i < names.Length; i++) + if(!keys.Contains(names[i])) + return false; + return true; + } + public bool HasField(string name) { + if (!IsObject) + return false; + for (int i = 0; i < keys.Count; i++) + if (keys[i] == name) + return true; + return false; + } + public void Clear() { + type = Type.NULL; + if(list != null) + list.Clear(); + if(keys != null) + keys.Clear(); + str = ""; + n = 0; + b = false; + } + /// + /// Copy a JSONObject. This could probably work better + /// + /// + public JSONObject Copy() { + return Create(Print()); + } + /* + * The Merge function is experimental. Use at your own risk. + */ + public void Merge(JSONObject obj) { + MergeRecur(this, obj); + } + /// + /// Merge object right into left recursively + /// + /// The left (base) object + /// The right (new) object + static void MergeRecur(JSONObject left, JSONObject right) { + if(left.type == Type.NULL) + left.Absorb(right); + else if(left.type == Type.OBJECT && right.type == Type.OBJECT) { + for(int i = 0; i < right.list.Count; i++) { + string key = right.keys[i]; + if(right[i].isContainer) { + if(left.HasField(key)) + MergeRecur(left[key], right[i]); + else + left.AddField(key, right[i]); + } else { + if(left.HasField(key)) + left.SetField(key, right[i]); + else + left.AddField(key, right[i]); + } + } + } else if(left.type == Type.ARRAY && right.type == Type.ARRAY) { + if(right.Count > left.Count) { + Debug.LogError("Cannot merge arrays when right object has more elements"); + return; + } + for(int i = 0; i < right.list.Count; i++) { + if(left[i].type == right[i].type) { //Only overwrite with the same type + if(left[i].isContainer) + MergeRecur(left[i], right[i]); + else { + left[i] = right[i]; + } + } + } + } + } + public void Bake() { + if(type != Type.BAKED) { + str = Print(); + type = Type.BAKED; + } + } + public IEnumerable BakeAsync() { + if(type != Type.BAKED) { + foreach(string s in PrintAsync()) { + if(s == null) + yield return s; + else { + str = s; + } + } + type = Type.BAKED; + } + } +#pragma warning disable 219 + public string Print(bool pretty = false) { + StringBuilder builder = new StringBuilder(); + Stringify(0, builder, pretty); + return builder.ToString(); + } + public IEnumerable PrintAsync(bool pretty = false) { + StringBuilder builder = new StringBuilder(); + printWatch.Reset(); + printWatch.Start(); + foreach(IEnumerable e in StringifyAsync(0, builder, pretty)) { + yield return null; + } + yield return builder.ToString(); + } +#pragma warning restore 219 + #region STRINGIFY + const float maxFrameTime = 0.008f; + static readonly Stopwatch printWatch = new Stopwatch(); + IEnumerable StringifyAsync(int depth, StringBuilder builder, bool pretty = false) { //Convert the JSONObject into a string + //Profiler.BeginSample("JSONprint"); + if(depth++ > MAX_DEPTH) { + Debug.Log("reached max depth!"); + yield break; + } + if(printWatch.Elapsed.TotalSeconds > maxFrameTime) { + printWatch.Reset(); + yield return null; + printWatch.Start(); + } + switch(type) { + case Type.BAKED: + builder.Append(str); + break; + case Type.STRING: + builder.AppendFormat("\"{0}\"", str); + break; + case Type.NUMBER: +#if USEFLOAT + if(float.IsInfinity(n)) + builder.Append(INFINITY); + else if(float.IsNegativeInfinity(n)) + builder.Append(NEGINFINITY); + else if(float.IsNaN(n)) + builder.Append(NaN); +#else + if(double.IsInfinity(n)) + builder.Append(INFINITY); + else if(double.IsNegativeInfinity(n)) + builder.Append(NEGINFINITY); + else if(double.IsNaN(n)) + builder.Append(NaN); +#endif + else + builder.Append(n.ToString()); + break; + case Type.OBJECT: + builder.Append("{"); + if(list.Count > 0) { +#if(PRETTY) //for a bit more readability, comment the define above to disable system-wide + if(pretty) + builder.Append("\n"); +#endif + for(int i = 0; i < list.Count; i++) { + string key = keys[i]; + JSONObject obj = list[i]; + if(obj) { +#if(PRETTY) + if(pretty) + for(int j = 0; j < depth; j++) + builder.Append("\t"); //for a bit more readability +#endif + builder.AppendFormat("\"{0}\":", key); + foreach(IEnumerable e in obj.StringifyAsync(depth, builder, pretty)) + yield return e; + builder.Append(","); +#if(PRETTY) + if(pretty) + builder.Append("\n"); +#endif + } + } +#if(PRETTY) + if(pretty) + builder.Length -= 2; + else +#endif + builder.Length--; + } +#if(PRETTY) + if(pretty && list.Count > 0) { + builder.Append("\n"); + for(int j = 0; j < depth - 1; j++) + builder.Append("\t"); //for a bit more readability + } +#endif + builder.Append("}"); + break; + case Type.ARRAY: + builder.Append("["); + if(list.Count > 0) { +#if(PRETTY) + if(pretty) + builder.Append("\n"); //for a bit more readability +#endif + for(int i = 0; i < list.Count; i++) { + if(list[i]) { +#if(PRETTY) + if(pretty) + for(int j = 0; j < depth; j++) + builder.Append("\t"); //for a bit more readability +#endif + foreach(IEnumerable e in list[i].StringifyAsync(depth, builder, pretty)) + yield return e; + builder.Append(","); +#if(PRETTY) + if(pretty) + builder.Append("\n"); //for a bit more readability +#endif + } + } +#if(PRETTY) + if(pretty) + builder.Length -= 2; + else +#endif + builder.Length--; + } +#if(PRETTY) + if(pretty && list.Count > 0) { + builder.Append("\n"); + for(int j = 0; j < depth - 1; j++) + builder.Append("\t"); //for a bit more readability + } +#endif + builder.Append("]"); + break; + case Type.BOOL: + if(b) + builder.Append("true"); + else + builder.Append("false"); + break; + case Type.NULL: + builder.Append("null"); + break; + } + //Profiler.EndSample(); + } + //TODO: Refactor Stringify functions to share core logic + /* + * I know, I know, this is really bad form. It turns out that there is a + * significant amount of garbage created when calling as a coroutine, so this + * method is duplicated. Hopefully there won't be too many future changes, but + * I would still like a more elegant way to optionaly yield + */ + void Stringify(int depth, StringBuilder builder, bool pretty = false) { //Convert the JSONObject into a string + //Profiler.BeginSample("JSONprint"); + if(depth++ > MAX_DEPTH) { + Debug.Log("reached max depth!"); + return; + } + switch(type) { + case Type.BAKED: + builder.Append(str); + break; + case Type.STRING: + builder.AppendFormat("\"{0}\"", str); + break; + case Type.NUMBER: +#if USEFLOAT + if(float.IsInfinity(n)) + builder.Append(INFINITY); + else if(float.IsNegativeInfinity(n)) + builder.Append(NEGINFINITY); + else if(float.IsNaN(n)) + builder.Append(NaN); +#else + if(double.IsInfinity(n)) + builder.Append(INFINITY); + else if(double.IsNegativeInfinity(n)) + builder.Append(NEGINFINITY); + else if(double.IsNaN(n)) + builder.Append(NaN); +#endif + else + builder.Append(n.ToString()); + break; + case Type.OBJECT: + builder.Append("{"); + if(list.Count > 0) { +#if(PRETTY) //for a bit more readability, comment the define above to disable system-wide + if(pretty) + builder.Append("\n"); +#endif + for(int i = 0; i < list.Count; i++) { + string key = keys[i]; + JSONObject obj = list[i]; + if(obj) { +#if(PRETTY) + if(pretty) + for(int j = 0; j < depth; j++) + builder.Append("\t"); //for a bit more readability +#endif + builder.AppendFormat("\"{0}\":", key); + obj.Stringify(depth, builder, pretty); + builder.Append(","); +#if(PRETTY) + if(pretty) + builder.Append("\n"); +#endif + } + } +#if(PRETTY) + if(pretty) + builder.Length -= 2; + else +#endif + builder.Length--; + } +#if(PRETTY) + if(pretty && list.Count > 0) { + builder.Append("\n"); + for(int j = 0; j < depth - 1; j++) + builder.Append("\t"); //for a bit more readability + } +#endif + builder.Append("}"); + break; + case Type.ARRAY: + builder.Append("["); + if(list.Count > 0) { +#if(PRETTY) + if(pretty) + builder.Append("\n"); //for a bit more readability +#endif + for(int i = 0; i < list.Count; i++) { + if(list[i]) { +#if(PRETTY) + if(pretty) + for(int j = 0; j < depth; j++) + builder.Append("\t"); //for a bit more readability +#endif + list[i].Stringify(depth, builder, pretty); + builder.Append(","); +#if(PRETTY) + if(pretty) + builder.Append("\n"); //for a bit more readability +#endif + } + } +#if(PRETTY) + if(pretty) + builder.Length -= 2; + else +#endif + builder.Length--; + } +#if(PRETTY) + if(pretty && list.Count > 0) { + builder.Append("\n"); + for(int j = 0; j < depth - 1; j++) + builder.Append("\t"); //for a bit more readability + } +#endif + builder.Append("]"); + break; + case Type.BOOL: + if(b) + builder.Append("true"); + else + builder.Append("false"); + break; + case Type.NULL: + builder.Append("null"); + break; + } + //Profiler.EndSample(); + } + #endregion + public static implicit operator WWWForm(JSONObject obj) { + WWWForm form = new WWWForm(); + for(int i = 0; i < obj.list.Count; i++) { + string key = i + ""; + if(obj.type == Type.OBJECT) + key = obj.keys[i]; + string val = obj.list[i].ToString(); + if(obj.list[i].type == Type.STRING) + val = val.Replace("\"", ""); + form.AddField(key, val); + } + return form; + } + public JSONObject this[int index] { + get { + if(list.Count > index) return list[index]; + return null; + } + set { + if(list.Count > index) + list[index] = value; + } + } + public JSONObject this[string index] { + get { + return GetField(index); + } + set { + SetField(index, value); + } + } + public override string ToString() { + return Print(); + } + public string ToString(bool pretty) { + return Print(pretty); + } + public Dictionary ToDictionary() { + if(type == Type.OBJECT) { + Dictionary result = new Dictionary(); + for(int i = 0; i < list.Count; i++) { + JSONObject val = list[i]; + switch(val.type) { + case Type.STRING: result.Add(keys[i], val.str); break; + case Type.NUMBER: result.Add(keys[i], val.n + ""); break; + case Type.BOOL: result.Add(keys[i], val.b + ""); break; + default: Debug.LogWarning("Omitting object: " + keys[i] + " in dictionary conversion"); break; + } + } + return result; + } + Debug.LogWarning("Tried to turn non-Object JSONObject into a dictionary"); + return null; + } + public static implicit operator bool(JSONObject o) { + return o != null; + } +#if POOLING + static bool pool = true; + public static void ClearPool() { + pool = false; + releaseQueue.Clear(); + pool = true; + } + + ~JSONObject() { + if(pool && releaseQueue.Count < MAX_POOL_SIZE) { + type = Type.NULL; + list = null; + keys = null; + str = ""; + n = 0; + b = false; + releaseQueue.Enqueue(this); + } + } +#endif +} \ No newline at end of file diff --git a/MoCha/Assets/Scripts/JSONObject.cs.meta b/MoCha/Assets/Scripts/JSONObject.cs.meta new file mode 100644 index 0000000..c095bab --- /dev/null +++ b/MoCha/Assets/Scripts/JSONObject.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: da64cad21a33a6444ac511376fcb771b +timeCreated: 1524716713 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/MoCha/Assets/Scripts/OAuth2AccessToken.cs b/MoCha/Assets/Scripts/OAuth2AccessToken.cs new file mode 100644 index 0000000..e12b10e --- /dev/null +++ b/MoCha/Assets/Scripts/OAuth2AccessToken.cs @@ -0,0 +1,10 @@ +namespace Assets.Scripts +{ + public class OAuth2AccessToken + { + public string Token { get; set; } + public string TokenType { get; set; } // "Bearer" is expected + public int ExpiresIn { get; set; } //maybe convert this to a DateTime ? + public string RefreshToken { get; set; } + } +} \ No newline at end of file diff --git a/MoCha/Assets/Scripts/OAuth2AccessToken.cs.meta b/MoCha/Assets/Scripts/OAuth2AccessToken.cs.meta new file mode 100644 index 0000000..320c6d8 --- /dev/null +++ b/MoCha/Assets/Scripts/OAuth2AccessToken.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 2e4069fa83cbbb041aa91e83f7ece28e +timeCreated: 1524716713 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/MoCha/ProjectSettings/ProjectSettings.asset b/MoCha/ProjectSettings/ProjectSettings.asset index f93fdd1e3d4a106919694408227b23b6d0453e63..d8a42fd8958e31040a217174a9390950cf663793 100644 GIT binary patch literal 56395 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 Date: Thu, 26 Apr 2018 05:33:52 -0500 Subject: [PATCH 02/13] Commit for testing XML. --- MoCha/Assets/Scenes/Main.unity | Bin 53688 -> 53792 bytes MoCha/Assets/Scripts/FitBitAPI.cs | 4 ++-- MoCha/ProjectSettings/ProjectSettings.asset | Bin 56395 -> 56411 bytes 3 files changed, 2 insertions(+), 2 deletions(-) diff --git a/MoCha/Assets/Scenes/Main.unity b/MoCha/Assets/Scenes/Main.unity index 1cef1c2cb4c2a6dc7a4a29afd11485808ca1f395..a35ec1e12d0e9a225fd93650bd59a34a2aed70a5 100644 GIT binary patch delta 770 zcmYL{%}Z2K7{;HOJHi!Ft{koD`)7s5H!GT!Nkc)R#EWL)yT~Nn#%XZqrlnYvg1v1sR&>RI~eUVH;!xdb9hkFi(&8Dw#b7oF_fR z%0yG985YTgsHVf9F#9-Ap*J1cI$jP_P}NJm8eeD9N5_}Y8ymZ4688i!W&w?S{;_)b zzF`G7{H`rw@it(J8Czgmm`|3WXAA5I+b8qr>sh-^YY!+GJ{l1p8pB7ux`%X%$sM!tgyFaUFJ}VFfVXL-zceM;zD>UleTxT zRe|gySDIUyN#`C@khusvp_=Wruys9MQmvzx!hb6-$+MtVszrmR#X5f1*uWQ^m2hgP_zQf=VPy9Hct5bP)Pl9qeR`+OAE$ z6dW9$X|gy)-jb+@qaY40;@C+XiejsFap?Kv28YAR`Q6LSz4_wi{iUCN8z_tcM~ zvowxR=Tv0=#r?`zso353@Bc$s$UDrHecCMqysw2*WmReGK>OTn7g&P0> diff --git a/MoCha/Assets/Scripts/FitBitAPI.cs b/MoCha/Assets/Scripts/FitBitAPI.cs index 4dfdbca..476f977 100644 --- a/MoCha/Assets/Scripts/FitBitAPI.cs +++ b/MoCha/Assets/Scripts/FitBitAPI.cs @@ -22,7 +22,7 @@ namespace Assets.Scripts.Fitbit //if you don't know how to do the callback through a native browser on a mobile device //http://technicalartistry.blogspot.ca/2016/01/fitbit-unity-oauth-2-and-native.html //can probably help :) - private const string CustomAndroidScheme = "mochaapp://TheCallback"; + private const string CustomAndroidScheme = "mocha://"; private const string _tokenUrl = "https://api.fitbit.com/oauth2/token"; private const string _baseGetUrl = "https://api.fitbit.com/1/user/-/"; @@ -107,7 +107,7 @@ namespace Assets.Scripts.Fitbit { //we don't have a refresh token so we gotta go through the whole auth process. var url = - "https://www.fitbit.com/oauth2/authorize?response_type=code&client_id=" + _clientId + "&redirect_uri=" + + "https://www.fitbit.com/oauth2/authorize?response_type=code&client_id=" + _clientId + "&prompt=login&redirect_uri=" + CallBackUrl + "&scope=activity%20nutrition%20heartrate%20location%20profile%20sleep%20weight%20social"; Application.OpenURL(url); diff --git a/MoCha/ProjectSettings/ProjectSettings.asset b/MoCha/ProjectSettings/ProjectSettings.asset index d8a42fd8958e31040a217174a9390950cf663793..78e4db1f91b8718bba54c452c338b85cc73a7cec 100644 GIT binary patch delta 49 zcmX@TgZcIjW)231a|{d&ccM3Pw47zM-rRdupLepsWfop`pr~VBN>P4h3IpTjy|?-p E0kLxt0ssI2 delta 35 tcmV+;0NnrExC6_$0|)>B&Hw-a+)J?tgv|jfvyII!4U;g?471qUg8}j14j}*l From 519dfff2bcef5ea5ed96e1da69be5c9108fef30b Mon Sep 17 00:00:00 2001 From: Patrick Kitchens Date: Thu, 26 Apr 2018 06:36:49 -0500 Subject: [PATCH 03/13] Updated, AndroidManifest still not working right --- MoCha/Assets/Scripts/FitBitAPI.cs | 41 +++---------------------------- 1 file changed, 4 insertions(+), 37 deletions(-) diff --git a/MoCha/Assets/Scripts/FitBitAPI.cs b/MoCha/Assets/Scripts/FitBitAPI.cs index 476f977..7563052 100644 --- a/MoCha/Assets/Scripts/FitBitAPI.cs +++ b/MoCha/Assets/Scripts/FitBitAPI.cs @@ -18,10 +18,6 @@ namespace Assets.Scripts.Fitbit private const string _consumerSecret = "69307b9f332caf9946ef4e23cabde2e4"; private const string _clientId = "22CX4L"; private const string _callbackURL = "http://localhost/callback"; - //If you're making an app for Android, fill in your custom scheme here from Fitbit - //if you don't know how to do the callback through a native browser on a mobile device - //http://technicalartistry.blogspot.ca/2016/01/fitbit-unity-oauth-2-and-native.html - //can probably help :) private const string CustomAndroidScheme = "mocha://"; private const string _tokenUrl = "https://api.fitbit.com/oauth2/token"; @@ -47,7 +43,6 @@ namespace Assets.Scripts.Fitbit private OAuth2AccessToken _oAuth2 = new OAuth2AccessToken(); public FitbitData _fitbitData = new FitbitData(); - //Debug String for Android private string _statusMessage; private string CallBackUrl @@ -79,19 +74,10 @@ namespace Assets.Scripts.Fitbit { _bFirstFire = false; } - GUI.Label(new Rect(10, 10, 500, 500), "Number Steps: " + _fitbitData.CurrentSteps); - - GUI.Label(new Rect(10, 20, 500, 500), "Calories: " + _fitbitData.CurrentCalories); - GUI.Label(new Rect(10, 40, 500, 500), "Distance Walked: " + _fitbitData.CurrentDistance); - GUI.Label(new Rect(10, 60, 500, 500), "Return Code " + _returnCode); } public void LoginToFitbit() { - //we'll check to see if we have the RefreshToken in PlayerPrefs or not. - //if we do, then we'll use the RefreshToken to get the data - //if not then we will just do the regular ask user to login to get data - //then save the tokens correctly. if (PlayerPrefs.HasKey("FitbitRefreshToken")) { @@ -105,7 +91,6 @@ namespace Assets.Scripts.Fitbit } public void UserAcceptOrDeny() { - //we don't have a refresh token so we gotta go through the whole auth process. var url = "https://www.fitbit.com/oauth2/authorize?response_type=code&client_id=" + _clientId + "&prompt=login&redirect_uri=" + CallBackUrl + @@ -125,7 +110,6 @@ namespace Assets.Scripts.Fitbit private void UseReturnCode() { Debug.Log("return code isn't empty"); - //not empty means we put a code in var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(_clientId + ":" + _consumerSecret); var encoded = Convert.ToBase64String(plainTextBytes); @@ -141,7 +125,7 @@ namespace Assets.Scripts.Fitbit _wwwRequest = new WWW(_tokenUrl, form.data, headers); StartCoroutine(WaitForAccess(_wwwRequest)); - //DIRTY DIRTY HACK + while (!_wwwRequest.isDone) { } @@ -152,8 +136,7 @@ namespace Assets.Scripts.Fitbit var parsed = new JSONObject(_wwwRequest.text); ParseAccessToken(parsed); Debug.Log("\nParsed Token: " + _oAuth2.Token); - - //now that we have the Auth Token, Lets use it and get data. + GetAllData(); Debug.Log("Steps from Fitbit: " + _fitbitData.CurrentSteps); _bGotTheData = true; @@ -174,14 +157,12 @@ namespace Assets.Scripts.Fitbit _wwwRequest = new WWW(_tokenUrl, form.data, headers); StartCoroutine(WaitForAccess(_wwwRequest)); - //DIRTY DIRTY HACK + while (!_wwwRequest.isDone) { } Debug.Log("RefreshToken wwwText: " + _wwwRequest.text); - //check to see if it's errored or not - //we have an error and thus should just redo the Auth. if (!String.IsNullOrEmpty(_wwwRequest.error)) { PlayerPrefs.DeleteKey("FitbitRefreshToken"); @@ -192,7 +173,6 @@ namespace Assets.Scripts.Fitbit else { Debug.Log("Using the Auth Token (UseRefreshToken)"); - //no errors so parse the accessToken and update everything :) var parsed = new JSONObject(_wwwRequest.text); ParseAccessToken(parsed); GetAllData(); @@ -203,8 +183,6 @@ namespace Assets.Scripts.Fitbit { if (string.IsNullOrEmpty(code)) return; - //we passed the full URL so we'll have to extract the - //We will add 6 to the string lenght to account for "?code=" _returnCode = code.Substring(CustomAndroidScheme.Length + 6); Debug.Log("Return Code is: " + _returnCode); @@ -228,8 +206,6 @@ namespace Assets.Scripts.Fitbit GetProfileData(); GetAllRelevantData(); BuildProfile(); - - //make sure the loading screen is open and change message _fitbitData.LastSyncTime = DateTime.Now.ToUniversalTime(); Debug.Log("LastSyncTime: " + DateTime.Now.ToUniversalTime().ToString("g")); } @@ -254,7 +230,6 @@ namespace Assets.Scripts.Fitbit Debug.Log("Doing GET Request"); StartCoroutine(WaitForAccess(_wwwRequest)); - //DIRTY DIRTY HACK while (!_wwwRequest.isDone) { } @@ -265,7 +240,6 @@ namespace Assets.Scripts.Fitbit private void GetCalories() { - //time for Getting Dataz var headers = new Dictionary(); headers["Authorization"] = "Bearer " + _oAuth2.Token; @@ -274,7 +248,6 @@ namespace Assets.Scripts.Fitbit Debug.Log("Doing Calories GET Request"); StartCoroutine(WaitForAccess(_wwwRequest)); - //DIRTY DIRTY HACK while (!_wwwRequest.isDone) { } @@ -283,7 +256,6 @@ namespace Assets.Scripts.Fitbit private void GetDistance() { - //time for Getting Dataz var headers = new Dictionary(); headers["Authorization"] = "Bearer " + _oAuth2.Token; @@ -292,7 +264,7 @@ namespace Assets.Scripts.Fitbit Debug.Log("Doing Distance GET Request"); StartCoroutine(WaitForAccess(_wwwRequest)); - //DIRTY DIRTY HACK + while (!_wwwRequest.isDone) { } @@ -302,7 +274,6 @@ namespace Assets.Scripts.Fitbit private void GetSteps() { - //time for Getting Dataz var headers = new Dictionary(); headers["Authorization"] = "Bearer " + _oAuth2.Token; @@ -311,7 +282,6 @@ namespace Assets.Scripts.Fitbit Debug.Log("Doing Steps GET Request"); StartCoroutine(WaitForAccess(_wwwRequest)); - //DIRTY DIRTY HACK while (!_wwwRequest.isDone) { } @@ -321,7 +291,6 @@ namespace Assets.Scripts.Fitbit private void GetSleep() { - //time for Getting Dataz var headers = new Dictionary(); headers["Authorization"] = "Bearer " + _oAuth2.Token; @@ -504,8 +473,6 @@ namespace Assets.Scripts.Fitbit Debug.Log("Steps from Fitbit: " + _fitbitData.CurrentSteps); Debug.Log(www.text); Debug.Log("Steps from Fitbit: " + _fitbitData.CurrentSteps); - //Debug.Log("WWW Ok!: " + www.text); - // _accessToken = www.responseHeaders["access_token"]; } if (www.error != null) { From e342a6a0ebf16b3266b89c3fd9e803211cabb0e4 Mon Sep 17 00:00:00 2001 From: shadow8t4 Date: Thu, 26 Apr 2018 09:37:47 -0500 Subject: [PATCH 04/13] Navigation Menu implemented. --- MoCha/Assets/Materials/Blackout.mat | Bin 0 -> 5168 bytes MoCha/Assets/Materials/Blackout.mat.meta | 10 +++++++ MoCha/Assets/Prefabs/Navigation.prefab | Bin 16972 -> 40680 bytes MoCha/Assets/Prefabs/Navigation.prefab.meta | 2 +- MoCha/Assets/Scenes/Home.unity | Bin 90388 -> 91244 bytes MoCha/Assets/Scenes/Stats.unity | Bin 91832 -> 89856 bytes MoCha/Assets/Scripts/NavigationManager.cs | 25 ++++++++++++++++++ .../Assets/Scripts/NavigationManager.cs.meta | 13 +++++++++ MoCha/Assets/Scripts/SceneLoader.cs | 8 ++++++ 9 files changed, 57 insertions(+), 1 deletion(-) create mode 100644 MoCha/Assets/Materials/Blackout.mat create mode 100644 MoCha/Assets/Materials/Blackout.mat.meta create mode 100644 MoCha/Assets/Scripts/NavigationManager.cs create mode 100644 MoCha/Assets/Scripts/NavigationManager.cs.meta diff --git a/MoCha/Assets/Materials/Blackout.mat b/MoCha/Assets/Materials/Blackout.mat new file mode 100644 index 0000000000000000000000000000000000000000..47953a2957b73f9e512d0e7874571083df96d716 GIT binary patch literal 5168 zcmeI0&umcehd$DJUYSRPnc1D2Rwax9zrt3QLzRMdM{M-F@2~nVo57W}!VX ziHRo<8jqfgi5|Qd^$#$?10>!I@j|?NG4bX_>+`(tJ44^4hMT9p&D)vxGvD`lzdvSX z-(4ZLeJsRdM}!bVLhQsrh@(eFPmCNJ8C@C`|E#aC7YbmH^TPW2_{`Apo7exIyE*y& z&%gg7stwRHxL)REv=c(4n6j=0sSpMHebq10?+PL<0#Zu%g4l-hJKzuF*q8G@@f$P_ zU`+dd#Z%1b6C==h8RLh{HB1FBh>!Y2`jgQqDSNJA>(D=KZ|e-?ydcg&{~H+5f38tT zl}=$4{;-qN=fXI7zw&cG=FrbUa@G6ACD?v|&hhq~7X&oK7&_x+XY2Lz5yeu)H^#do z=i1M+7}K9eaYPzuZ~4hWZsz9@x$3r`yK=7U^&ZBIYd1O@^Lzm-wbeOp7)9^#4-Hqh z$++gM<7eR1*@MnToj<|9#yS0ef-ohw{ok8&JI_y&qcQ&nPiA5~wf-RL&UJa8>UC}XVcL&V%hrFETy4jTj+2+HJn%WwewM5}ykdAiuHMG^ zU3B{SDvriaRo_1he=Xot}0l8Tr0DuPX;v+=#k z_sk&^*9>7wZpX#~>tWoR`EEti-tZ zF29H_#4zm3D&FIm%y{R}3mfS7v;7nd9le zU4&E+CvMR6g5@hN)(sL~nhLwP)bLueb#@lxYBx^8&b$n;$fd6AN)aa!rd)QHYwn6@ zc`>D0dhNO!$1)ZRftRe+qi{t=$y%c=Wdfmwdrh_s^kCF+F3Z*F;F>Yl15J}|Bsrt$ z`ckZlHJr~aEyYS^#t&WPXf^c1C>D`e7K_3~AyA_2!}zb;5mv}FUdx;M)Hb6?#$h*V z%J^`XE<1}|&riI-k*i7M<}OOErrHIhgM%SoFT&HOA!AcMbtd73{WIE_viCT;qFN^-YX zZM#7reNIE$jqWs7WV7qL(K+m0eePfBl+kQN&3o~t6?I=Uuu*P$NnD@_tk7zq!s?irsk@83-ReEJIAtq`_`>7RkQ3lFgBR7p{1370sgjxNB{r; literal 0 HcmV?d00001 diff --git a/MoCha/Assets/Materials/Blackout.mat.meta b/MoCha/Assets/Materials/Blackout.mat.meta new file mode 100644 index 0000000..80f29d7 --- /dev/null +++ b/MoCha/Assets/Materials/Blackout.mat.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: 8b09d9a7c0cb3ca42a798802c96d28c8 +timeCreated: 1524748932 +licenseType: Free +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/MoCha/Assets/Prefabs/Navigation.prefab b/MoCha/Assets/Prefabs/Navigation.prefab index 5ae202c03bc31e3d3d069e9d7e3dae44c7b0dbe5..b46718cb0789fc505727477d315b406555edcbca 100644 GIT binary patch literal 40680 zcmeHP3w%_?)t{T25QHkALQo(C1>|KUfQVFJLwE!TBn=PI;$xF6$;z@DH=7W!*6XX% zm!gFvzL8?JN)h`&YW)fHb00!Xxa%7c!gWzlb@$R+yY20d3GyeAC4|N?&4^hbk1E46&5tTts=u*$KFe z9XxV&mY7Aqb@0fEI!ewAQAj-Fl!rXW0=Mv62alY`0S^Gr^vKx-xQvuwvTU;HB63-gR z3*42!C=!b$rUn;>ie+U2rq!t5Y$?&3G!&+fefYjdt{uGpmLK-s-|%Ut|DYqTq?kc* z9Vz5s4bF?CWpsozICSL>#Q?>`Hzj6C936oUhB3fzs)N+P_^nL`a;Sl)1_slS21hif zBMpwk4LRTkQGE<}@W{77E6p?UVQ}&Tz?A`H0|kSVPZ2nbA`f^N9EGQg{xt9=QXcI^ zRJfW5EGG;O<9d5xa1^c#coF5H0~j0x7bC~<(CGBsz83- zaJdFY(Vs(QKpzGt8GUJR0?p|wgVUV8GC05u@hIu%Vj>IOz~CVG$AdIDvcJ>>=kcHn zjwR_}fvcpt(2r|yl-@oi{Q!r-5h5VVlP;|~${7@u!J&yf55%=NzFfn>+{=P z@C^amH8J(2IURk$hdi|uK_`bIf}c)5i8ZIAFZiHy4Mos7l_G+lPJf9tr!&C84e6Myq&)OC zkRk%c+g)^BN3oFNX%rEl&v|5renn~6ZuEtqR)8;+x1OXN=nST4X!uh$KE#JVW8*`8 zI2;zx8Rp=M@3WK#-_t23~*LVvOoI z^F7mtGvCn;uK0dPd9;`8C50TK<<;{TLUsDA=d*n{^BwEMneW#fJWclFe#%4t=TJmI zzoUP<7z!V!V8RWNP1q2M{RtcI;AvtEVN)n#d`@t1HQ#yO1qdfoK~ZhUc%965a7E{Q zn-2UE1phcMkXUm%lN?;pxx}V38AK@f=}eJWb2?KU+z^)$jUQ5keZ$-!@rh2F^lR?2 z@o5h3-H1#l+z6n&cOx;Fr#SX6gYxdKFz$sv(2|Do8!M6;c1-yf}l<+GkVt$nar@$M1ZdZlG zEQ#yw3ORTOIc}E|9ni=6rs!vSVs&Y#SSL0vlzc1mCa~W_7Y_EnA4tXvEXaV=ylW(DH0Jzs) zT@GAE?|l5Wjkk7RLfeXPB_BX|GIWR#QrnyUvqKR&C20kMD(PH;CGHrk{IZxKFpd&%SQo~!)67WX(4iC`MU^*bBo1CZKhou;~01!ifR+1 zHW_eMfoJ=0IHka`*sJoY-`V-hA)KAQa!O(m#NyTuxP>}t;(AK1p$PmGx+>fhzog`o zHh!vud!4oZ4(@f<1^}l3XAN}NS(BS-3wQ^Cjq58Eq36>mBKVy(Y^Ie{lj(7420OTN z*50B#R5&c*|5y5WAvLHV;(+F&z*Asonfz33}Q|RF_ z8<(5ud{ur2wQw8Zpd&ZabOoKe2!F-Kr-Kd!rvEPC^k2ZG5@ZzxW)QBjEPPJA3~H-jCn+ zbsStcp`mzPD8Htf_5q}Oy1Nl6AV*Gl)|63Bp8ZSy;#e);uZ$GH#a|Mxfxm}p#pD!+ zqw2PWAs%?)oRjA~yK`!|^32$8s@9!dcgMN0?GrBkeDIoW&)#w6X|K?#CeBM!qw1)q z<<7LDw=Ir(T5Ms<7lm#zZdRi9rmL}+t2=Nd_cwq3f z5O_z&p0w*}d2g4vw=LAM_M=1xo|E*nBproswQ=cb**H8fdc1{r*`8Luk_VpC8+Liu z(^7PB%ntg})6(eEV+#^zPYdk={R4#4e}NsJvKtETX0NTdZNWJB_9h(ku@gjKPc+ZQ zaoYj`_+3j*6 zU&-^cDY0l`QZRutTPLZ!N@U@{<7!`KhnGpGkdWDlr4ghjhH4U1!YD8^9JPO+8LYQc z`E&*x#rYxqF4Gg2P7TEthZ6Cngp`KMtLB92@nc~u9$rRdgOTF8P<&w|wuHcW^kf`8 zYo|j+;b>@fb+BALXd^4j6F^hEb?ubRyGkd_TJl)Vn|HnQY&fHI#tor6F8ku#c`uB- z=pX$b#z~DjEjW4tm@nt#(Gx%;U^TO2SU1$p+-t|OY`nF0Ob*L*(G;57?H`|vnLn?~ zfw4dDa@~%j!&0tVq+;*EXeUzd(P4SuKz9tYBRDL{Rlxeb?TR%;b8nsg&F@c{ciPOy z(knX?iZec})CiQeU@bYoJ4p3*K^H2N>S14;^TI1JDXLkex*g}F9qr%v91Kr^r+V0z z>2ydzC)2^zQ{br{He@=-P$>N)U^vA3#FBhm0G*UQIS;I?N7fY(=JY@4@SF8$FE(c(^~B^ z9lv&&4r>>q>95q=IBmw=4~#w`atKwvDSUIZ3x2(h7g7%Rv4FMm@U?+MS2_-#8aPI% z!ig{WxbU4p8@%=M%(t5lXTHb#aOQi0gDd(MQXceAbZ~FGFv)ekOdo5Hjx&9%JuE-o z-B?69j34+k`4+~N_fgT4fCqqkee{!oQv{B8e=ZU3yBi8ur{Mjm4D^P(PmJUAn)?xV zpA>FLI(3vsd$TDTGO9ff(@}Syq@40D4b#bS%BxfGD<}`X{UmM?Ev3)zQy%nBk@#vt zz4|=WhqFGxpS&EWJnIuyK;edXjoP(_@*OD-q$os=Q=Z4eX+E6k4{~rtXFcUX2X~*6 z(HY{yna)rLS9BhxJm?H_aBq8|Kb=0)$#rl=XFKIV2m5BdJhw~TeRA8&bn=|?iVp6= zfzAjA_sS#hK52SmI=K4;zNK^q?YtY)YGX z+Qd+ie3cH?JLyn`#txgCNuh|`G?j$wVhMo(y1MdT8M3|fM>U)tOL#Ev((GGIf!kz@ zDH;@iw`a+uv4q`AX&eFqt1>U&yKRjr22tix8@uff1LAM})D)`;yVAx^%m@#-VJnrR zO*&&;hm07v@nchLAdKlHmalkjeQvrKPU~*iu3K36=Upq8q~mbGsk>l%!R_xhq>Di` z>$vVO2Ogide|5UJm#`n&b$8V5t1{kB7h|Y}=h@gl_x$zRDgPu7moS#)rjP#d=Dxk@ zBBz6($ADDZI#fh+D*l}=mJ`NpduwvHrI(mgkyaMw`~H33d|>0C3}I>5HQ&uRFmO1P zqtVCZHlDxdzBfivIl`D;?o;ngT|PEL>?Mr#T=iLWeDv!XqKZ}{F1M#=|BtGQGQ>{8 znBLAM>tjEimmx0h6Oe6&ba>j8DfiuH7xl1 z@dF>q5CO7SEX!-6jkIaY{}t*fTXAHMpd%^6}fVJ!24 z{$1`j_GE~jw7S*W<)%OOo%>>aI*1j7aovw@JNDsM@;ivVgfWi`7uG#7`uYy^5VA|} zwVz#4cWo1uBaGYDqv@XKHm&ai6o`GQ}>!SXT{WznNyGuQIB;QJ2to zqyJ*ddmkM)Y2+%So>oEJ)~4Yl%5w9D++MWGSWYV-WAjgZ(2BRmfYFw^*{@wqqUe{m@%5mlU-83Wp z$FDUQ)r4`mLE|rOxc!|5!|LbKyJg!0r?2~r7Z zzf2pvv%b-&B8+*Iu3B5ZnTxo_J*Bt|!(t8p~;w8fDYVebxBUghv~V&9p+X zUgCTA-}#$AHX2)K72>*`-pP)A@^Pc_GOa*d_uIv@R_5(*G`i-wvUCi8)uvn*1URVld*TSi#;*+zA?|8)ns%e1I_f7ZP*gNHPK{rrDqjbf2Gfa{?w(u$rwY= zDKNdA3+k_a&}uRY=@|vacC1-Yu={(|4thR;>7CPXUuo7`Cz=;ePzO+C-o(8>d-x|g zeY=~>HEh_L1t0bp+}+%uVdMnRsDykdRA|7?P;G?@q$*)v&9&_M5fs=`8bk4O{p0Be~bVmSyhM zu$!J4F>QwEY33BT^y)_5*}3%XUS=U-O~iwiB~d+VfBDckz0IA3ZLqQRzq+pOvkQBh zD`?`cwXwRax+^Ld_BO{%cCqLkca&dwAJrv{>!v?n)%}EZRCkKYBkjqUJ#zZi^uG=5V{Raf z<=gT0vYJt2`$z;} znIGO$kZo2MyXA(ze&ED=W@no@B|_}A^}J`=B~8CB&o+C0!OS8?*8usXI z1J@2%l5JL%x;!TJd~@h;?$0&_-3?*B75Pgq2(QaFn>1|xHT!#P-z!?9 z5B`0&xrH!p?@Nzm&C7i`+pM4KmU}mN%2m5w$u_&rbIWa7f6?kwc9MLAG2g)1yYD|? zSGGC-To>EeaCJ?m%)aI>4O{oKP8;s&-q&0{-z|4?=UbM&Hn6XmbDoR6pHcL7c5z>G z6JabL)?kC;`c3Em0UJ-G-~G?HA#{=W_DprZD2?(vmp%Yk`T?9KmxNxtD4E-L(hpbO zHE6dLIBsj*<0e4yqko(>%E-HF@-6#bfBS^9?)kPt=e>W;@2*?>;^bd^t4EJ9yR$+H z{mz};rtEvXIRDRheB5eKb!rFVNVrooO`#hcf8A!VX~pf!zV^tI)7LaE&$;cTtA60si_H;z)|$Y3mM<&MdmU!Pwhi>z zx5Aj|L{WQ1LE6E&beD%7vadi{e*n*9e3>8XlWi61^SX&Nukp-#Vz7KsB|Q}%C2p|6 zE%648*6`=~it@ZhBhCH}_@`6E4XU=_3t9+l?~vy832F9wk!IfvGQh7@FA%g%`&kZN zx4@6rU8LC`MVkH9BOwQm173H)kNp#**?&G#Ydji@MGT&Y2No8DZPU(0{bOMvww{=?=g|)y&KZJ$2t_9e3?Dq z-`KwZeaw-Wp=fPe&U^M%&=&Ufk>-5~(!94kls2M1w*_eqYNYui3YS9K0t$n)iCF=eDx1%$I#Q@Z!A#(!3W1U#w|IYF%M}5j=UXfi#~b9BKaS zOM)lw3z6o%{gLMH_|?Rd_mSYwXApG~`=n9B0Tl8Z^mPtwWr zTyX$OFh3q=ygx)4-peA*=V6D^&erhdJpg#|o)>983p&#M%X>%gS;>oxZ?@3SEnpJO1+XLLuZpLw4RUVPqxG@pgGHDC6Jc;60Q ze9i}6SSyM`^geIAEEbGcw8|IfJ_9Wd+@I`+@_7e-=QAs$`AiyVKC^}#ZS4W5ua6o51(lw z?c5WfG@tE)e_M|u)-#_qfj6HKBh6>h-1fHedsxqWW(Hn-uK>JoR!yHMTu5IrY?JZC z`sQ;s@N>?yDb4pEfb-e>k<>SzlYt+fMzb}_#J`Ah03+= zucBws9RoM+*D9DQuKE8upfsqzxnww=96q3wx@ZSY~5{d{yE=A<1xthcCiK(SBIi>ekKn? z`F9>W|4aTkKL^QeOg1mtlRwJO7PCGM)eqq3eVI;s*DF6yt?Q$`*&DtOz&hYF&h~U3 z;9qwRb$;=C0j$gRKEL?g30)uUZGQ3d8LR`oSJ9s47mow>Rg%q%_T=aCdo4UBaBWZf zE%Y_+C2{+CT;Qtjv-rIkE_bMQncqQTI=K4JKiZQ&$?qPq-jnI0J?P)$H zyO)iz!TR8Ff~!71lbxfrxAmQ$17=?E zsP}{M+y%dDLdh2G8h=kf*O%Xpz`lOf?FicH4`>ti3i^G1Zl{FpKf0ag?{RQBT>biJ zkNYuQAMMSq^7|I71AdmdJ=s(;+Xq{owmH{5#6~?MHh$ zzu@obu-=mCqdnPEey&2-M|-oU{5&=5fZvsEPxjP*UytntuDU((+uc;<{C-QSa=ia% z-KQ$Y=ddl6V|&+9Ilmo9#n-=&OI6N)u9K=9KTq9~eE$2Rsp$FVZ>n8{wGyA|9zfR<^0drrYgtx(OS~8|J))KJ^yomsml59pQI}1KMzh-&i@=r zs&f8)Q>t>TKmB*?N1EsPIZpM9{!WayEa$xC8Ko;|JMRH#xW}&WbAtNsUnUpMyAb%D zNu>EbS)^MIhbJ$OFE1a^)C2Qy-!IVLq2l-Ql8sSCh3hlToF~W{KTbKRQ=rM}>h_xL z7gJEzmgUsn(d759lJRos=`;^sPJVuy=vi*mY2u@@S4`l@{ja~XtAB@pzj>hc+e%99 zFX>Oxw)?9(pH37=w}lg_jMQziw(5FiyQa~kq*q>*2j=4XyL{fdob#4vl&-Cki`N&e z9wlA=3TGbfxYXYT=Jy(t>A+i`xg30d^EWIZoEuZi$^ET=Q$_#IhW?EomP%dSwkkdB zdRz!Z^mXg|o7bo2v~@)1rEvWnV7;W9<~lB7r&`tD>}Ppvr`98v<2lXw=GViMi~UKW zYq>GCTs+qFZx^v`=if9LrEVzC*T={%QhH0iiVohQePlmSqYZIER}08@7ZIlqhtZ(rD7 z^U_W&CzsQ|VZ@mC>X*&=wN?Gf-yo)1mK#&c#dc5s_KE(TEner6>yqi>x{KzmF3mH6{Gu(EHB<8NfPXNCZJ0SL3#o0;MQgS*0QS4f4%a$yea`&$n7DCzsQ|Imnpz>er$3YpeR1 z&u^SsGLc$;Tu$E;G3LDLNqNmwk#Lh1FtN4?(pQ|a}%AScMRhf=HbfAW6WDm z&v6|clj&CVBfpYk9ASr$>HooM>8Z^vab?kNUSE^*PIW#PbSCf=`cEk&QmM^@-0_y|lgZCex$7 z#(3*;?(p=;=hjS3U0aq*Un{+JId^z+@%b`SYpq=RI_#~>xxH@4i5?4Pg{&98?i7e8OONq3+G&^W3 zih^cApe75PX+I*6pbOcB`eR6f6xlr_u(0#G@6~mA;r-s{Je+gBbIx<#-cdX}!E^w& z{Q$W|0AL{8r86?^;F@GLa;T9xWy#CF=3{E`5!WGe-d;zH zE4iCl6##bP=z&AdWh1F0-Rv+Kdh(Tsn;c3X8?Nc`u;XN<6R9NfNRr3j+Ix-#$qBj?1@@R9MuaJ<}R_?uPWpgS7N%lu5jFMFH@v3{W#8ZzE(9AZk`R$FZl zD=acD#4;6T@4m{^3(@~(PjG!RiER^cqT1wLA2f0Vo~caG$oUtrT*n{yQ%jmwOa`0m zvAE^59^32@IMAs=cdJDm(hK9yZj1?+Dl8@*D|}Hn-JZ4hvm9UAl3xEwx>#X#*E)2c S(i+3H6hbp>>M-H0PRnoGKrAW% diff --git a/MoCha/Assets/Prefabs/Navigation.prefab.meta b/MoCha/Assets/Prefabs/Navigation.prefab.meta index a619c74..c9cf27e 100644 --- a/MoCha/Assets/Prefabs/Navigation.prefab.meta +++ b/MoCha/Assets/Prefabs/Navigation.prefab.meta @@ -1,6 +1,6 @@ fileFormatVersion: 2 guid: 326b00dfcab7e8c4da45c990cef3c9b6 -timeCreated: 1524679668 +timeCreated: 1524753018 licenseType: Free NativeFormatImporter: externalObjects: {} diff --git a/MoCha/Assets/Scenes/Home.unity b/MoCha/Assets/Scenes/Home.unity index 3751dd5b9b00b124b444682849f51966bb6cbbe0..0e6547a417ff4b2db4d3a185fec1289d58977553 100644 GIT binary patch delta 6378 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 DNd&J7 delta 5890 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 delta 6273 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 diff --git a/MoCha/Assets/Scripts/NavigationManager.cs b/MoCha/Assets/Scripts/NavigationManager.cs new file mode 100644 index 0000000..e255db4 --- /dev/null +++ b/MoCha/Assets/Scripts/NavigationManager.cs @@ -0,0 +1,25 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.UI; + +public class NavigationManager : MonoBehaviour +{ + private GameObject navMenu; + + public void Start() + { + //navMenu = GameObject.Find("Navigation Menu"); + navMenu = gameObject.transform.Find("Navigation Menu").gameObject; + } + + public void OpenNavMenu() + { + navMenu.SetActive (true); + } + + public void CloseNavMenu() + { + navMenu.SetActive (false); + } +} diff --git a/MoCha/Assets/Scripts/NavigationManager.cs.meta b/MoCha/Assets/Scripts/NavigationManager.cs.meta new file mode 100644 index 0000000..c392c20 --- /dev/null +++ b/MoCha/Assets/Scripts/NavigationManager.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 658e48ac784a5d543bc76161835f7156 +timeCreated: 1524750227 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/MoCha/Assets/Scripts/SceneLoader.cs b/MoCha/Assets/Scripts/SceneLoader.cs index c318319..d61788b 100644 --- a/MoCha/Assets/Scripts/SceneLoader.cs +++ b/MoCha/Assets/Scripts/SceneLoader.cs @@ -26,6 +26,14 @@ public class SceneLoader : MonoBehaviour { if (!(SceneManager.GetActiveScene ().name == "StepCounter")) SceneManager.LoadScene ("StepCounter"); break; + case "Profile": + if (!(SceneManager.GetActiveScene ().name == "Stats")) + SceneManager.LoadScene ("Stats"); + break; + case "Monster Creator": + if (!(SceneManager.GetActiveScene ().name == "MonsterCreator")) + SceneManager.LoadScene ("MonsterCreator"); + break; default: if (!(SceneManager.GetActiveScene ().name == scenetext)) SceneManager.LoadScene (scenetext); From 5e7b5f407e5358d92013598e7656fb0334323cdd Mon Sep 17 00:00:00 2001 From: shadow8t4 Date: Thu, 26 Apr 2018 09:54:29 -0500 Subject: [PATCH 05/13] Navigation plbs. --- MoCha/Assets/Prefabs/Navigation.prefab | Bin 40680 -> 40680 bytes MoCha/Assets/Scenes/Home.unity | Bin 91244 -> 91940 bytes 2 files changed, 0 insertions(+), 0 deletions(-) diff --git a/MoCha/Assets/Prefabs/Navigation.prefab b/MoCha/Assets/Prefabs/Navigation.prefab index b46718cb0789fc505727477d315b406555edcbca..5f7be4ea31d1a225211558ddc0db946fff60848f 100644 GIT binary patch delta 22 ecmaE{m+8e`rVS$D>~Xg|H6K(=-z*(|)*S$PPzpl; delta 22 ecmaE{m+8e`rVS$D>?fYT<8v{dx>-8>tUCaHhYDc; diff --git a/MoCha/Assets/Scenes/Home.unity b/MoCha/Assets/Scenes/Home.unity index 0e6547a417ff4b2db4d3a185fec1289d58977553..c3bad2a1f20f7a80fa53379367a8b2fe280c673a 100644 GIT binary patch delta 6937 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 NqZ_VmBk&~8{y)V029*E+ From 9e847cb6589909bca24c71b6a496ec4c2027633d Mon Sep 17 00:00:00 2001 From: Patrick Kitchens Date: Thu, 26 Apr 2018 10:59:14 -0500 Subject: [PATCH 06/13] ok --- .../Scripts/CustomAndroidPlugin.cs.meta | 5 ++++ MoCha/Assets/Scripts/FitBitAPI.cs | 26 ++++-------------- MoCha/Assets/Scripts/FitBitAPI.cs.meta | 5 ++++ MoCha/Assets/Scripts/FitbitCaller.cs.meta | 5 ++++ MoCha/Assets/Scripts/FitbitData.cs.meta | 5 ++++ MoCha/Assets/Scripts/JSONObject.cs.meta | 5 ++++ .../Assets/Scripts/OAuth2AccessToken.cs.meta | 5 ++++ MoCha/UpgradeLog.htm | Bin 0 -> 33450 bytes 8 files changed, 36 insertions(+), 20 deletions(-) create mode 100644 MoCha/UpgradeLog.htm diff --git a/MoCha/Assets/Scripts/CustomAndroidPlugin.cs.meta b/MoCha/Assets/Scripts/CustomAndroidPlugin.cs.meta index a23005d..a7829bd 100644 --- a/MoCha/Assets/Scripts/CustomAndroidPlugin.cs.meta +++ b/MoCha/Assets/Scripts/CustomAndroidPlugin.cs.meta @@ -1,6 +1,11 @@ fileFormatVersion: 2 +<<<<<<< Updated upstream guid: 80685d60eb42cd340a5c76d410187801 timeCreated: 1524716619 +======= +guid: 1d9a971c325c98e4a81ea4ec2e52aed6 +timeCreated: 1524756178 +>>>>>>> Stashed changes licenseType: Free MonoImporter: externalObjects: {} diff --git a/MoCha/Assets/Scripts/FitBitAPI.cs b/MoCha/Assets/Scripts/FitBitAPI.cs index 7563052..aca4ed7 100644 --- a/MoCha/Assets/Scripts/FitBitAPI.cs +++ b/MoCha/Assets/Scripts/FitBitAPI.cs @@ -42,7 +42,7 @@ namespace Assets.Scripts.Fitbit private OAuth2AccessToken _oAuth2 = new OAuth2AccessToken(); public FitbitData _fitbitData = new FitbitData(); - + private string _statusMessage; private string CallBackUrl @@ -67,7 +67,6 @@ namespace Assets.Scripts.Fitbit { DontDestroyOnLoad(this); } - private void OnGUI() { if (!_bGotTheData && !string.IsNullOrEmpty(_statusMessage) && _bFirstFire) @@ -124,7 +123,6 @@ namespace Assets.Scripts.Fitbit _wwwRequest = new WWW(_tokenUrl, form.data, headers); StartCoroutine(WaitForAccess(_wwwRequest)); - while (!_wwwRequest.isDone) { @@ -136,7 +134,6 @@ namespace Assets.Scripts.Fitbit var parsed = new JSONObject(_wwwRequest.text); ParseAccessToken(parsed); Debug.Log("\nParsed Token: " + _oAuth2.Token); - GetAllData(); Debug.Log("Steps from Fitbit: " + _fitbitData.CurrentSteps); _bGotTheData = true; @@ -157,7 +154,6 @@ namespace Assets.Scripts.Fitbit _wwwRequest = new WWW(_tokenUrl, form.data, headers); StartCoroutine(WaitForAccess(_wwwRequest)); - while (!_wwwRequest.isDone) { } @@ -185,7 +181,6 @@ namespace Assets.Scripts.Fitbit return; _returnCode = code.Substring(CustomAndroidScheme.Length + 6); Debug.Log("Return Code is: " + _returnCode); - UseReturnCode(); } @@ -197,9 +192,6 @@ namespace Assets.Scripts.Fitbit _returnCode = code; UseReturnCode(); } - - - public void GetAllData() { @@ -229,7 +221,7 @@ namespace Assets.Scripts.Fitbit _wwwRequest = new WWW(_profileUrl, null, headers); Debug.Log("Doing GET Request"); StartCoroutine(WaitForAccess(_wwwRequest)); - + while (!_wwwRequest.isDone) { } @@ -247,7 +239,7 @@ namespace Assets.Scripts.Fitbit _wwwRequest = new WWW(_caloriesUrl, null, headers); Debug.Log("Doing Calories GET Request"); StartCoroutine(WaitForAccess(_wwwRequest)); - + while (!_wwwRequest.isDone) { } @@ -263,8 +255,7 @@ namespace Assets.Scripts.Fitbit _wwwRequest = new WWW(_distanceUrl, null, headers); Debug.Log("Doing Distance GET Request"); StartCoroutine(WaitForAccess(_wwwRequest)); - - + while (!_wwwRequest.isDone) { } @@ -281,7 +272,7 @@ namespace Assets.Scripts.Fitbit _wwwRequest = new WWW(_stepsUrl, null, headers); Debug.Log("Doing Steps GET Request"); StartCoroutine(WaitForAccess(_wwwRequest)); - + while (!_wwwRequest.isDone) { } @@ -324,14 +315,13 @@ namespace Assets.Scripts.Fitbit { if (kvp.Key == "avatar") continue; - + //put a space between the camelCase var tempKey = Regex.Replace(kvp.Key, "(\\B[A-Z])", " $1"); //then capitalize the first letter UppercaseFirst(tempKey); } } - _bGotTheData = true; } #endregion @@ -406,7 +396,6 @@ namespace Assets.Scripts.Fitbit XDocument doc = XDocument.Parse(json.InnerXml); var root = doc.Descendants("value").FirstOrDefault(); _fitbitData.CurrentSteps = ToInt(root.Value); - Debug.Log("Steps from Fitbit: " + _fitbitData.CurrentSteps); } @@ -480,7 +469,6 @@ namespace Assets.Scripts.Fitbit Debug.Log(www.error); } Debug.Log("end of WaitForAccess \n"); - } //just a utility function to get the correct date format for activity calls that require one @@ -509,8 +497,6 @@ namespace Assets.Scripts.Fitbit return date; } - - private int ToInt(string thing) { var temp = 0; diff --git a/MoCha/Assets/Scripts/FitBitAPI.cs.meta b/MoCha/Assets/Scripts/FitBitAPI.cs.meta index 8514324..beb83a4 100644 --- a/MoCha/Assets/Scripts/FitBitAPI.cs.meta +++ b/MoCha/Assets/Scripts/FitBitAPI.cs.meta @@ -1,6 +1,11 @@ fileFormatVersion: 2 +<<<<<<< Updated upstream guid: aa5e856e9b878764db7c192f3aa20277 timeCreated: 1524716713 +======= +guid: 849590d4a954ae445aa5db73d734450c +timeCreated: 1524756213 +>>>>>>> Stashed changes licenseType: Free MonoImporter: externalObjects: {} diff --git a/MoCha/Assets/Scripts/FitbitCaller.cs.meta b/MoCha/Assets/Scripts/FitbitCaller.cs.meta index 1dc151a..57119f4 100644 --- a/MoCha/Assets/Scripts/FitbitCaller.cs.meta +++ b/MoCha/Assets/Scripts/FitbitCaller.cs.meta @@ -1,6 +1,11 @@ fileFormatVersion: 2 +<<<<<<< Updated upstream guid: 36444c03eedb84147a326a329de30d0e timeCreated: 1524716713 +======= +guid: 80ba6a52e9d55564fbe8130844b17f29 +timeCreated: 1524756213 +>>>>>>> Stashed changes licenseType: Free MonoImporter: externalObjects: {} diff --git a/MoCha/Assets/Scripts/FitbitData.cs.meta b/MoCha/Assets/Scripts/FitbitData.cs.meta index add5ba3..e0b1ea8 100644 --- a/MoCha/Assets/Scripts/FitbitData.cs.meta +++ b/MoCha/Assets/Scripts/FitbitData.cs.meta @@ -1,6 +1,11 @@ fileFormatVersion: 2 +<<<<<<< Updated upstream guid: 7a928c029cb14204588724261a513ec1 timeCreated: 1524716713 +======= +guid: 1d8622418b8bead4cad17658d650c6c2 +timeCreated: 1524756213 +>>>>>>> Stashed changes licenseType: Free MonoImporter: externalObjects: {} diff --git a/MoCha/Assets/Scripts/JSONObject.cs.meta b/MoCha/Assets/Scripts/JSONObject.cs.meta index c095bab..7347c44 100644 --- a/MoCha/Assets/Scripts/JSONObject.cs.meta +++ b/MoCha/Assets/Scripts/JSONObject.cs.meta @@ -1,6 +1,11 @@ fileFormatVersion: 2 +<<<<<<< Updated upstream guid: da64cad21a33a6444ac511376fcb771b timeCreated: 1524716713 +======= +guid: 9101b04121334074fb6e70fc34eeb3f9 +timeCreated: 1524756213 +>>>>>>> Stashed changes licenseType: Free MonoImporter: externalObjects: {} diff --git a/MoCha/Assets/Scripts/OAuth2AccessToken.cs.meta b/MoCha/Assets/Scripts/OAuth2AccessToken.cs.meta index 320c6d8..ba51381 100644 --- a/MoCha/Assets/Scripts/OAuth2AccessToken.cs.meta +++ b/MoCha/Assets/Scripts/OAuth2AccessToken.cs.meta @@ -1,6 +1,11 @@ fileFormatVersion: 2 +<<<<<<< Updated upstream guid: 2e4069fa83cbbb041aa91e83f7ece28e timeCreated: 1524716713 +======= +guid: 1d4c10710438d404085599a6fe50d37b +timeCreated: 1524756213 +>>>>>>> Stashed changes licenseType: Free MonoImporter: externalObjects: {} diff --git a/MoCha/UpgradeLog.htm b/MoCha/UpgradeLog.htm new file mode 100644 index 0000000000000000000000000000000000000000..d82fb2a026ca7f1a5e53aecda426f1e07087e23c GIT binary patch literal 33450 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 Date: Thu, 26 Apr 2018 11:00:35 -0500 Subject: [PATCH 07/13] samn don --- MoCha/ProjectSettings/ProjectSettings.asset | Bin 56411 -> 56411 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/MoCha/ProjectSettings/ProjectSettings.asset b/MoCha/ProjectSettings/ProjectSettings.asset index 78e4db1f91b8718bba54c452c338b85cc73a7cec..96001e65ca06fbf5e4939917ff35ae77a9fa56cc 100644 GIT binary patch delta 20 ccmcb;gZcIj<_#_v8HFZ4JTI|1_ToP-0BpSqNdN!< delta 20 ccmcb;gZcIj<_#_vStS@47$i1(UKHX609hgj5dZ)H From 27e2c484e670dd6786c49151a8c13656af9f9bf1 Mon Sep 17 00:00:00 2001 From: shadow8t4 Date: Thu, 26 Apr 2018 11:04:53 -0500 Subject: [PATCH 08/13] Oh plbs --- .gitignore | 2 +- MoCha/Assets/Plugins/Newtonsoft.Json.dll | Bin 0 -> 433664 bytes MoCha/Assets/Plugins/Newtonsoft.Json.dll.meta | 32 ++++++++++++++++++ MoCha/ProjectSettings/ProjectSettings.asset | Bin 56411 -> 56451 bytes 4 files changed, 33 insertions(+), 1 deletion(-) create mode 100644 MoCha/Assets/Plugins/Newtonsoft.Json.dll create mode 100644 MoCha/Assets/Plugins/Newtonsoft.Json.dll.meta diff --git a/.gitignore b/.gitignore index b004b77..efc0001 100644 --- a/.gitignore +++ b/.gitignore @@ -4,7 +4,7 @@ **/[Bb]uild/ **/[Bb]uilds/ **/Assets/AssetStoreTools* -**/Assets/Plugins/* +**/Assets/Plugins/Android/AndroidManifest.xml # Autogenerated VS/MD solution and project files **/.vs/ diff --git a/MoCha/Assets/Plugins/Newtonsoft.Json.dll b/MoCha/Assets/Plugins/Newtonsoft.Json.dll new file mode 100644 index 0000000000000000000000000000000000000000..5f3d9bd1d363c41f1648975d50b920b2d1bdc57e GIT binary patch literal 433664 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
  • qX+xRf*>+W%Uf_*`ex6Q?vahU=z^(nQmy+FZC0e6=oXmU`xN~xW9H0Oe=t>Qtd&qvpZ7ZaRhzH@OB+J54>i zyD~zSh-;DRe%S)D0>p8#@WBGGYT#DTcj@eb^@tHtI4A1CElue zORjnwpF{C(7^I?#`cqNeJU(xx{6;rNhmf|hA-~rAgJt%qO(r|~e`v=UB^ZDbl#LRM zZg!Nw_~2~4o;SOJgM$NuW;+jc#z8Zv=Tr~tJ^ADkjyTFZqgSJ*+`l)(>_gbPfQE>k zN!!$yH?L(X*kYShp=*wNQ3V7Oc>H}vO)tuRP@J`cL8FAmpL5px5rJTk$z7@SQSwQf z!*-3WaWaXP^23E1FB+C37RR2I1!8%-P<4PbeKbmFEDnAFe3jth-VvC<8!3~~XBY`| z`vhdSnZh)x3&G$}d58r`d=M;9=Ar!kl)uliTKt2*^NIKx{w5`aN(ve652Ay}v6J8Y z(p{fh6;ebC+uo<-Ye_YEZC6gK{_UL7)_)egqRTyXU0S~pmQ)I-xinO|F_PI#(F+N> zo%PpY>6TgEOwM&rT_Zk|KcdF->k>pv;(coB#^aKKB{uX%CJMMTGSQ`(;vc%%KY44w&8L&5bOlDVn#EJ{G%{CWeW|90ls57cv?LE4A@*CB8^b-rkNc#<3Hn zHs1WC4F)+4S05Ws$K_b@bHuhK@l*Gfg+K*6C>6&86ymB@#SxIJqt4;FK+TwpzH(2e zXD7eRU`U!|-+oU}9q1kCvt#sf@02)!WM1^zl#uYwM%vQN=oqJYmHR4=W*VDVd&&We znBN`y9a;}luIs3N4H~y_sMjjZWzA#;7v{~~5jB_=2hmcu-Z%YY-{Ne*j6;XAK15~A z=Zr3Rtk!MOKh$Y5h-8w9X&kC;gadbz-cG9~Uqd8!V8#7f9no!kA&{_hNpga|t}<$Z zXoDLyjd9F#-%3oo7Ax(?9%=sb;%WI$9Ld+*w4dFH)eaXisc zF3+k9b?ecKs3>>E(X(`1T>h~(+E9KsR?l&D);7tE zVgV%=e`I2_XLms@BQAC(OF)jCLd$75$w^l`mCZ1@aLLoPu=23CUV_YG=EDwftQ6_w zWxksTgQJ^^zEil!^F>^M{Maram2y4#lOpN`NwL4hd=KKUlza#O55LtUefmYY#PUzS zDSR}6cYo#9U&vo=byz)rEYzS4SMn#%2!F$g8-Mc=>0HR|MBR$rM(0Kk%Cnb1Rc4Ig za);M2aT{3|jjJ;UfK4gD9B+1qSo64~OOe4Phul$(L5cQfL(`1Jr=^L_0pRo$U=9Ee zNde}76_Ke5B|RezFb9AK3or{iDu?Gw*B(nE#O7X_v{X(}IPo5o#*Xl$%GomvGLu&yow31W(4)3^wa!(^*Cir%V znwjtb!rH_{Gr`@rW`(LlQ=TOv(brvWjeGF6UfkNf#Z9X5OV*S0t>{xTtq-{Q{|ScA zgIGz>8xbdw=%?D%rRWIop9gpVfU)IjG<^#mqT!I~zkXQQ#B>(ers2aOpgs#aFiiFC(|sL%^W<@D`H)H}liF9N3H^ zxM*W&%4|{eeyo&d`-0X4O*A8jgU3hV?+eCD%{ALdjTo0#CoF~D(zBGM=F2)kLzWgE zKb!e1J$kLigwN&OzA$<)h_HVV@^#Fh=^OXcj@1n@YQO5^OSzhKBn}L*3#D9hczfoG zTDG~FPl*Tpa?KtNGy=DdGf`v-<08UXC4Pi2dK=hr2V^_DOs`SmwsAHWy%q)(6T>R4 znj>PF5`%ihuj|^;v|2U(6KxvCQv`(ZvBG1(1^8j>84~_Q99g)Ku{GS)c_BsViu@DQ zSLvpK2@;*GzSepWYOk7kCUp;*pF1<@!@w?5(f}%RdWeH?%yYpzbNU1&Lo3vGZ+ScK z@WiP(V;_bm#&X->cswq_#U~59d|;}MHJLts2mn7nG!#9Vve%9I&C6*HW7|U;T+vsk z+f^>h>gG>qj``7Jh&#jyr&a#9L>L}F*+m(dIL41xY0Z8+L%+#0W}KsZ2PYP(T{;(R zM5ikzuX063bS9;8ggr!)ZpE2)&M~}MkaJu})B@h9hxLQQX$VAsmGkDOQe;9mHYE>nP0w-e zo~P&POLFl>2BJ(*`@vB36tdtR1yfEX4Mh)^KU>FMIy&uaoL!xkG3zdRXnHv^PfmyR zdPCumzx_e#$C$+!D+8yJ7MkY6SYCxw1)^4a3eLS)NTkBzUox3WX4hLXhq2#T#JqjD zrdN;Wwe}EgMm`6_YU=bO6ow)C=q$ook75GM2;>4>`+1pD$nkdV^*g#5L4B#4nR92V zD_+N_naIIVk-=DNod!B1{KKG}ix0+E>=w9o@uH1PfASuK&JAy+98MLw%dxyz6<<77{c1J-D30228fh`s$`xX` z_3S}EO_?Tgr><>F07e~Od-rEw;I3eZt*(bzto zkXK0wBsUa2)_Gm~7-8TVOBD z-Hb=*%){%B$f?IRz6hHQ-JRz6b0$pYI*lXi6np0|RLk*~=dX{yp~Np(ZMbV#D{-vq$l{#>AFkzDK)c97kmITmhnPz;^Wit$>0&;WrI=cvTF z8LDB7j=kVqj0xk4b1#*9#JL&PVLZT(mp2?xM)5FuxY*ZPtl>EzWB2DV{OaqZKHxA# z`LR1nmMD)@6cZU`qx0p~Tao8z*t%&oST2{DM(RUNqqTI}Im!24zOWUU$yNMd9Vu%I z%3!W9S6`Y7#uwwTmDm|a04J1UxQ$cJfn#VkTq#EOQYaq@8Hz9p!t{%kzKvqM!9rK7 z4sUul6W5K&kI?d%f!^rxiq(fSLWdI}%SrR%rzfjqcHzR5HH$X!SDAd3 z^~BtK)q!KuykY#!H0HAD1I0uHbGa6KvfFdONM5-QY}KN+_?LU@D@b=4>6}*m;6Qnx zQtsPb9x%=Nv2x#bsG?WzE%$AcBYqvb9H4_ewL?8p8hcUb%WX6MqCnQUgu!SRB9$+i z>|vxHMAf#uSf$76&*s@zQyDn5VzV`qxT23kQzYXxnw8_$-Xn-=JI29&AFz=d(Up7# zHcm9Z+*iPQPkv}i(y^QWq+ww1!`eG*oKl$4@Xtv3B{!umOOJ=@&cRbM$ynC`lhzUi$k&d0lrM!0XUJ4uo%*_7sdp}wY2aHmkO zI$-8~`D9eD1xqn*J0J^N5{7+q7sI}E1D9^aP%njOiwSAYT$5m24*K$E+VryaGVXiG zcy2%5NX+V3*n9(1B34UCZ>YW7OwAsWniSZolF%2!(wQ4UP@JPJtI)O>P@ zbwz%1-h3LFSlY!0SX6gcQx+Ce_ElKaJ{cNs>oSsg&SD?GhR2q$`8jIif)F{@4@2xI z0*SD(Tr#|9sB$SdGkYeu<@yR|+9FHWy9y>HRoDaNGkX~aH|;Y%MmGO=KAC`>c|L=# za_k&%tfgT-s5pA?=8rCnWdp)-i>@pgeAfNq=7?;od0h6CMUQV1hUXDt~OBd(b88rC=jhX6LwKT~_f)S=c zlWaxC+qG6TjLfqCNJmP+21*j8TB!l11lBI-!K8D9vRtmEZm45q1B!PUE9n~jRjcmfox*uAX{T`iC+Zub3#5k zzHwn+mKX^7PA4H|ByxS(n4|M9<870DAu+IKVKEBC2;)~Nk0P3p=-Cw;$@Xr#z&^9K z6ewC9#ae%2?2T84c*_k)F`W7)?aRWv2*rjCY+D=+n68kH``b@skK4OvIeX>iz3Cih zInw?Hb=0qlCKVdPesk*Dga9OgZh*L6uOHhr7DhH4?tCNNyO`#SI_V1wDF=ps8o`+b zXY1%7zxnwzZoy9Ocrs20crKNZ=Af`8>lJJ(x23)Rxg)dW?HM+-C;%gycodbsnZC$2 zs($mNXC}xyfsDgFyIq@Z?sOd0yj$V6M!fM^iObfAlH+QF?iGTo8ZJFAy(W8zo^Ey& zd?X*xX~`{=Pf}xVI-3NI~a1X<zBBQ z^^rm@-b}7pv)X6(v!j2o#`o5?y5j0snpcEE{3LZWM~X!hv$=X09|qAZ2fek!a`CA| zNEirR?ZqakyM{Ve*#0dVvEEbIrf z^aaLHD(u$+Y!0^XVu;o&03;y{jJ#DNZ16A-X|Wb7k%_RQ%c)4cKaCeX*=FjASlF|K z*$DQRBom^GPPTZ7+H}tvhT|`)N#6z0Vvy|1+T_W*`5cU4fZE9n4$55pip(lEXG)m@ zgApDUdER0#S(c$1nE?;!>xFcwOiKs#slZ7())yKhjMR!BUrWz$XDq&wFLdf@)PP5? z`m(+|$uVIFhJcoPDJYM?Fvy8CFA5#!8|3N`*KpJIv?Tl+7Q|KFOqwUW3Y#IM0WVik z7bRrplzC)lQ$lw7vbF}%)yBCD-uvl(Z?1f%)+Z`NbG%LVo)o zzfnw=mU6@6=OLgA!s-M$T3epl#}=%sHMjH?t7ox>*4OtHy!KkEyukVTo3AZK)l;Z?y_% zy1?IC;qu0j~@KK zjh?l~Uz7Ia_KOOi0+ z^jIY`L{%?S?iuafbS92T{RBqOc*H`N!XyDQ$@9i7iWm%X%WRb7fqF6dgDPb7S1Y2= zQ_BzY<70mbHJz~}2X?_GaKlOwl@Cln2Oocj)_?ACVgGx%N^=rcYnh}~B<39q_pBQ% z1kIZ|U9^f^k{CJ#XWwh&ibl3}DRdum^aNe^YrXbPi+Xfi1#;t-IEI0LbT$#TK3*5DBPyZx!qZu*NMqN)Y)_*;v1br!4{&dSgfxv4E83;2K$gwBAhIi`#75KwQwEH_XW-0 z)6MBn9PpF)5e#2Zqv75ibcpNg`ZJQ2K*4Hwytlk~+4v>p#iM=WYicL7j?~_uL`_Pr zCfu(qSxc8ojHY9|8cZ!+Szl^5U5)X^ObVK(Klgy+Eu7k-afVtF4d^#NLCh!_XMUt{ zrfYx6n*Zd?^?%IVrs6jG-eOg6u;$I3o_*1M)Un@ZRhA8O-sx zfsMyJq+}p}fbqzUTRNn!@#u&OT4y#KH$aDrNwUEbk`Wt^CB|cMpYfP;q>)n#S4?|6 z?tvUk{i&PibPtA{4F(Y%*LPQDICi>DeJ7cqWPC3&K1-}g(dmX9)*OBwqsgQUFS#{w zbxRrCd45~G@b5DLKfLY!nE=}pc+taXt=7|+6g?FT){ER~5lYs&Jneo1f92e0@A!qa zi=FVy);B~$?x++g(CIHoieiV>#f@2R)rn=E&slen9kMe@o_=C-X5%Xy6+BrpE0kabb?79YZ&M^D5$Qrr#^$l2yykz|~YuT}X4RvbNZ@Ju|rYp7_mWIhXb zSl@)zWgO*FV{y4>Zx~9={y9p*djkjrfsZ9OSPxG z0#)V}PL-LV=%ibNy>KELo7r-2du;aF*o1akORb#LVo_e{TB;9~Wwp-WVjMzuu;0VV zK);iyEGaKG!9uyW+;1Y4Net7W)oPo?jSrW*f9j!pk|8NACPF34a7xb{%O+Y&Pb-&A zZHeQ&G*1)#3=WnDr+SprKzY!%d#K_MP@HytgGiyB}zQ)F?@+z8Um1~*=fn}Rts~BZ>PFh`n!*F?cioV2#ZE}2A9!`%B ztL0%kJ{(-y3GD9#_PfB5@<_~ntT?#3c2Ie>;d%Fra9LJfItB<<$=9HRUxRy(U3=rR(X3v!c+`D+yWYLJIYh3h_4GN)r;tiuw}y97H|`xqQ5GuMeeO16>cJD@iQU)$2%CFZV*Pb~_Su zF*3*c>N?uv$T6aFn@vkR7_8r=A zt%U2Tm#xCb#f6FKg~UX&~^h(^U$?X$c%waZ=; zKCR3)U)qk(@f$nA?(-vFm#HuJvM?)cw2_gYiAqR(D~Q*ktnt#dRU9ua&l;EFI(i|O zl4~#mY=8Q@fBf^G3>(Icmw72IyNhv?l}3+3$IKLQ7)<|`Jx&n?0lSu@=_U0r*mv7L ztm3NRdW!68)z5Xa-V!vTIeYtgpz}x=yQHD2E7F5DD3r;wHw{Wg4+q zLqtfm!+JfD1Xj8wf#d8A(yJ%bj1Dg7c%Mk{WD-$o0+p{NIJ&o8Q|v_Fo6s{`{*=qhXRcO6Ug9> z0h=#LaH4=xr6<`+by#pwjyI;1gKa`)65Z-V++>ua*9!_x*d#Ly4!MGn5y=}iN+sxi zr_(&@dhJV+Wr1@BN9;K=Kw8{OD=4$-Q3(03{K9;>lN2 z7@mJLB25%Wz2*t|wFgZ@vh(N~TlkdecQ>CL)34}Z^mNK3$8uIU_|XM;QH1S6XwRt# z@BD0`yE)+TZ8Iqem6L7Q=6qGP=l%s$`L=wj!NQ(T#0I8NYGMN>PcB)FHRcitg5Hp4;M~QxH!Htd`Yh_#OuR3vju(nt~+UYu&(o5qIr*q^yBTj?Dd3v2@ zgL&%EO9=+-mXOi7r(LR;8M2v$#l3R#8;cYWbf=~ zrSNxq;e2LQlv%00u=YKiCuUx5Yv|PVI5`e_J`{E^JNX!V+}*ehpDYBufNzQK3;FWE zY%X8jd^9m~W}eeDCl1x6kQLcjcTDU-JOfCa3uDbvjd^2q9^~lFYtM&5h0`6}&3Ezx z{1mF=L1B0T5zrC4lF{$XE_M-(oExYEIZlrk4AY!D7b^@T%7N1h&S2_~VoyMW)z8k^ z3fnk6XS}wLq|cqrTmu{93P>`S0N2>?+A4?GjR!<*&*9QT$tHFpyQQmv8@oM>U4%~( z%sI&tt$RDIx$$=KoP8*yRE8I&Re(wOePzoo6apB4X=ObWYRk+m(!%mvE8n^r#YB&%4$ z1<|u;3v?+Sx$(hO7jASMmbnP#uFw?dFHhIj*=U`*aeXl5pk!{~o&>H+`@@O&Fvvv?Mx^Chm zugcVuN?dfO(C5Kp-#u#2vpGw}_`DFXZ_01ZJ}Yo34Fu6%>g2mu@8`iZH}(FZ))U@c zEpze4kLQRyhNcp2Dg`C?2Ir~k&^t0nXj;x|8 zaQeMTo7`#{*v7Mz=%Fkjj?COFl2(Tb*`+uFUeE=6X#&jJu}>27*=^uQpu*8DF7r3z zMp-V{elY191^5>o|JB04c8U2U?JLt#=)Ofx_cRH)Lm|PoGsq^rf%JRMi=!Li>*9CP zHgt$=B%s^HNMfIyanJ1pbq<1VrYI4_UocV{JqV^KFW%h^EW%f2z2>z)0cB;4AjzbRQ1h8-K%42?9*5Wtr2fa+LbM|8k@6T^jBUzAIM|j ztXdCL^Ex7fHXmel$tIZjO!JQr>=GAya?K-Nnye{VC;T({=&5AP9kxfMVeXEYTW>6^ ztrUQ*v>JFfj-&*xxkCl3 zpe{vS^^k;s^?#A}p8cdnVbkr6pA1IEqp%6xsbQ4ld5rrSK1(+o=6p*Ne46WCmb4MF zPm#ifn>a`5eA9wWh+7zcxkJ{(zhpDVQ1)*6xO<=l@ih#zV%P(_lC)Iw+O)K;R!47I zsvCKRWWuko39Dwfuq4^NZ}j*PU6lDB*v8MbA@^pUOCxgTB3_)ibThtnyppcEv+8rQ0YK?= ze*Xx*`j<5M(es*od_j|cwbKa3=i9LCNKxji2ypS1QvTOvgfCCJHMzNYzhz(qfHK4z zYPW-)r0$Qp`ls{jClXIbZZ{%pX?$;BO8)cCS8k~pGhkQrz*9S zt`*6*%Np|tzN3-(%u|xGQeDI%;~`;Aq`@97A*Xchx&QK4-_c%s_AUPn+&-9JeyYf~ z@C!aZv`dS>{;_vXsFclBQ}fo)VdS(!Y}hQKJ+wv1#zx)T3cP<=b-G$!m}2ad75Ben z27cCyo=J(y7v+9i+3!E!|NM9IJrF6NW3)#@;+}am<1R4eYw0Hh8tkT@K-F`$p1C}7 zuEu^Y9h@%*Tg2e+wRK%&y|R)b~2RB#>cW;tZfw5$uPI}a|mzB z*`c!Of?AVvI7X0B#8q-8VMYvf7Yt>jHvQW(22n;m$*H%bt3YQTSm;^>_MonVnd{&l zkTIfpsfgy1a^4;9=u#2a_fqN!EeNqj_%F$5E?LPJMH)Si&1`u~X3Wvi$7W{kF-0-N zL0d9+{>B}{h^AgjOzjbA*ZW;3)vl0gt($JStlW%vcTw~*;AoQlOWaZ}L;d@E%6yIJ zI4=Nln|7<^gxC_}bMVOd7uyKGvLL>bMPu(GyPn1= zH1B1`uLLsqf4x7Craw8GFm0s;-3j61xz??n9!(5j2$-`r!HRir0V&sRP&@8;de@KD zjb@SyD6H=&tT&vd(T2XnRMEq+ z2)UAt{XP_!_v7hB#~{1SzAmge^5k@A8e`q-qf_--+bFG@V-C4%*KVC9i06Zg4Ke?#1R`jW%&*Zry0zMFW~@Nf8Fvox{Lu2Jx$ahwkuy2WX$QU)7w5tSrEm2aY$0f+OXK^8Z9ifdk|GNX)hp#`L{?oq% zJ?XtyC$et0nZP8@t46lJ9L9PGS0AlO^o&rVxZc*K_U$hJ>uFCk6bBZ$Yg)M)?V*ca zXlX}wN9zJ)C&mo0(}x)l*J78r#0^-4$^BdvLvGo1RcygEFL$X6k!RrUd+FwoUGw6> z=;+1th`rSwjyU%dvh^j7C3ozR$&bd*fsF|2qlgux;8h=TF%qwfvVr}}wB%}aF0Ho( zYu>cvY77`NBk~t8r!&YsMljj&dbl)8al;t zBe#1!@uZk($^hI(?^>}!w_ZT^gT+42Pbu63GynK5jlkX5bRmxVbQMYmx+{z_=lpOlH^i=Vle>sPe1B$Fok3+fq_%7oK-e|vX<~Q2SEw?$tjf8e#c~PmZ~|>Vz5|SwO>omm!qXb#=tG96SeW4O z-#}*znailR*6P5Sw_{>BS2l*llyz6*&mKIFQ{L!&ZBF?+yW2!rJAlAmybA4VQgp(6 z&Y7LG_FdiO%AB6A`UGZJ?|)P7>397v%H_uI!Xn{jodf$Mb@I(jD~Ec|kwx4*KQ1pkH+d{cv8; zkGg|?FfZu7?x63?3;J$%kgPIw>i@g$pzqBK`hIuNujd8*raS1Kc|rGf2g&?Zr>sAB z2mNJU&|kZQ{x&b@@7+QFm>0CSJLsSDf-v9L=}KRo_CN``gBHyT^16ev^Mb^GI#jXgSYp+{a$tlVvSP(B4BF|3{;g*%kfj@lcyhv3=y4|72 ziHo7hRv^B1UaW%@3tNB@OF`(3n0-6xwZ0MJ1pQi+(NWi%pyOT+qk@KQAD-Unm(;&du8aw61^4DH$bp4z&6 z7##t`;`J8liwiD7uHcg7t)L!mhvpk!&KXWD4VnM2vYx;R3K9!UO}{|L3SM*{wG)D< z#&84|-9$KywKptw1iI+n2z!gA-RaVm33aJYtty zi*Dfu&D;+H&DnFL;J(~UJ?72Sqe_#8%{Gq5u(h@)ZvH+c(Jqzo>(0PGkKU@hWz7p- zl~C~mL~)OeCONL?ZGLn=@e3{V1H!AY;N#BpS=-;3S>g6Vj+cHr^=##+m~6bO0%2(N zs6^4ehtjt$$ zCgmatZY#}82;U9=^IFPGG&$Xep^NDc%dhU@Y@D@VicTp)E4rCc&!G=!_Y@Sj6VAE@NQXcsu%T ziEAQ1pnu$E`>f&CyJ@}XJ^ZZfI7eFVO`*dbXSMad6zYtT z?odX1`qnwSrOub+{!2|{%5r1ACv)PN*v$}f;Bky$0Ul3jc-v$&G;$M78dA>Efm{}J4Ca9{z6cuQL)98EAG&&Ve&v# zieCI-e#ag|r03I$t&b?uM-@q-W0#~BN59x*ag;0df$A$ee3N|P**Q}altaBk8A5xa zV)MsJAWq$d*o^B^$PHUxV#U9zO(zy(AX#muJh@|$K}kE!Gm6Nvq&$zR|2uiwoxYU* zr1?TJcw(`LlF8`lH@}X8W}XhdY3&Z_?X1RES?#1_fnYTAUdEo^C^c_n&O2L>LFKSg zbM0ApD`a?8R^AsY)OmfxSm&&r|s=MruB0kGcDDXcF{Fn_le)}!}!E;oAc zbR)shSmH&LDl`bU#K z=Y{*^bGzm9!~NxxuIR45+&|0wCwOI}hcRj~Wh})1i~g#%KF)8=W`AY4htPZSl}@p{^VNS{U^OZ5kQ6glpuDUxL1q`VK#iR`g{o>0e@d7J zv!CXZjX%S0F#B14NzBL(=ZEwDWd& z77~2H%J3~Dh$MBUpDe@D{xJV;2dP=BMKMWS*ncgM7zuNsRqJo#k<`&d>2&;Ym!WLv z`VRZcv+8tz8$8k?>*gBWsIj~#T1~qoUEJ$H@rarQpt@PNyyh0AgJrzPC9Pt317Oeqf^eM=kMMHg%aoUVttt*Ac)A^?NGAEA7W|9p#o}(cR2O9DB$)+>!qCUXk zTr__c$eYl=i^=~(ng?#ctd`(|9M%Q1KWO7Kdmm0Lc=KC3(jPry$ch|_D*)IzRhmbE zTQ~i}a9r^!*GfDTL#!aJlFjw=DN}R3d9~GvqxFS#>QI(8u{jWBiTbUEht98|yv%by zb2eptSoN#MKXm9WYd))uuG99GT1U%p4)-%F(Y;o$(lCDzVN-V{)e+tLzgw4q1J!e?;~C_{aP*9A|&h_7Ur+c)Ag%O@#Y}X+L~%em@L#h;Dn7iRj*c zUtm9M$j~2~-xcyo_r~=FMPkd!@bB>x24A$#pZys~+V}@-2#dxfQTzPapA+mQ)$?b6 z(f0XnX#GE_PvyY%5$}IIbwf1-8RjWtQta zp0Rg%v%hM$h?|_f-t4adxtTcT&Hkq2dA?^Wmv6+_o7Hj^B<|m)xs2VIOmgz+%;@>~ zbVd1HC--?py`JGmP=l3zslMd)2aEbge#z}m9nS`D_RsjNSI5Sqzu?|63$rwKqc=J_ zgJN6yq`EgP52vxLao!B(JB@$WI(-9e{1MtX+X(H&-?8kha@bl7!xb0!!EKM*%DS|* zL|V*}8!RuF@rt<(zYN3C@`dLTd9-AoW&C>6Du4q$mHF6Ry|qIM(^y0b!ij2O8nsUG za?zpmK|SaEV}eN!4_LaF!V|NceTcdl#~9D92iwqiV2>oiinuArZJidQOJBu z)VEbc!hPM)o3ZrHB-V#a8Elp#fX;Z1?XC0DDJ~;yo!^x{I|+q3{2(s^9`r<+x&6b z59C<}&>G;U-LKSX5WmYa9#W9i$>sS;<+%i)@~rR;r}f+PUX%1Kc~$|;&l5a{0j52+ z6n7V%pHiM9z?A1QzTvcf=jFK^Kx+j*Z9LENrdQ%m@*Ijs6-e7VJU^{GR{>Ir9ORO!aoGU9!9VZ38pysQ~7 zWN=y@7<*S9Qz~PfH{?gB$kjnLeGSQdIksbW7np!p6OBDy;3pS7{{biE#zNNce3Hom z*#8B-Gs;;EE5YtCR=jnFXOQ6Sk8q>aTaXHMf z)#J8PEk2rL1XQ9LAyfA$ngy;@;IRZwe!-I321nA+_zD_X zPS*yf-davA^(dawq4QXqQR74M3wy&AYJf=nC=_Z>RwmVnOZUlT;_TK+<-+-XI~R2j zxfJ(?qsrw_3dbnGUsh~chFAuq9c{!DE&NuA11FK zH0S7G`-vt6dtbV~x2EvUY~;raTASoPTJG%3G5YicGsp6EbKTGAjA72|tORIg#mDij zuOC_mZc+1`qNbs?~g_ZBKSOSQWY?}dW)kWJp@K<>KSB)k?={ufpLXH|ZTn7z0Q;p543 z{b_EV+0Yh&KgreH5q7IrHnWtkquWUAf}u9u_7l48>Y2@KBi@%Nr?m>2Q9_`91&z>L z^IBeHzPV0ONErdf0C(r(e}XQI{K09ojqPYuDvef1qw%&(&YcT7DkntX`c|hT&iL17 zQvR1U=6pRSaxvv#F(ClRdXmw16@RjnP&b?(bBNzW=O zl}sK~xla^kPR8*S)df=YVP*SVl@KHkGV;aS?>W@bo}9>LJuV12e{?=&)gK(V?`Euh zXe`w|XFEu16}+8|!J_)=U`{$xHu@%pvYu&P zweBLLoq}7$HB3oG+|V6yo1m?aDx%;PQI7g(_j5tm?7Ul0>Be%PRJ3Tj08ELLEX+~? ztsKN7%`%uf0+2(lKkM1+MU~dcjAk+l<|f*KU~YlY<7lLvf?EXP=u$6EBX9(z#B&L(3Ykp$?wQ$K0I$|OMF zo%%@wMw0-2ck0IlG>-+%uG!zU%s@MT#sQe4g`Vx@97BZ4t440pKl4!BVUpHC$ z-}q}zW!C8WbIIpxl##8RjXCJ0^xbWvjlJ3)_oJi?z~^XjQNY0>y}FfGXKSZ<`P)Vh zKNkwSAzK(NtS8QBF?;HH1>Di+`23IoRSwQhd~XdK{n=AjfyRyr zbZ4^JQ!hT-?sexJ!ZEqo(S|CHkM1x8!9P{ZO+oitfG%saA~%s0ueb*3erW1V({V>sRdB%GT{iOkXjz{qwnMiRhLX^dqF;EidF zjFk!C0cniULIQbn8fCPYKsdJl{}}rY@TiKY?YZ}EPj8z-V3UxL zC5;q%mrkUG5<*d`AkBpYPfx+1XP6oJ!fV& z0sX%3&-3Knd1ua?>GjT?E48@%lnput85NhmvWfG_1Sp&3KAAveQ`aXGq--|%WP+7V zmQN-`*`Q}tVTCFiolL=Qg=&O}XgtA%hlflt9&S4A!N+wd-U@TE#c}t;& zPsUpeG`?{U@A8&IvQNfa5H!X~8E;7>`eeLCk?xc6mIWRMtN6H7e5me7J#osWzE37z z+4x2)SAw!>;FGDWY<$C=D^c0dm?$+TDI4FQ=BlD>-toyKOPgYvle)rYoX7hAmhiVdBw>qW30#;N9>o#?_J<_wu4ER$7dXPB zS%f;BqrNu40fm@iSSZ8?`r3lj7wl5m7ff=&QVy3w9`&_7DHnn!$ngsyxezIb55GNBm+&PxDHcj%p;8PN zNS1x3QmPAcB}ut3$Q9H22M3+{qI`-vqQ5BW1SqEI3N7}IsNc`&7iV23kOejom}B>V zC|#F3Vu}{k5#;C7&YC-Na#-~l^%jL_LmbZJ%N&6+@$98F075hhz*!j z&>pujDhBPG-r^cbh6$Y!J!qZKg?@cUv3%liVTsjv5eX9T$G?UrpZ$#^Z)!^xeHFIX zCM!YQ!%7}JUCZP=Nsvfc{;;NkG6|&#J(`0K6?2Gz@)s-SZsi0`{P~@Kh1R`HgumDG zFM%HA1TaLay#$@l&=q0c`f%iWmdTfk9Hu{zESL6FsNy5e9A$6XhtkHRl%tEDQ$1|) za1ND|;`dBbp29Oe1dF0>f)esPPG(OpU}QH`1$S?lsQjdBA21a3F%@yYLKjL}E)bO{ z?iS{lvOI5ncrf%hQX+hr<5yVX^Q467GCxPk0iV`OJ^_=AoYZM5r_@b89!^~O{Km$D zBc=Pp3FwOilvNwQ!sZ*j@%Kgr&Afb6$^`z$sGz~qR*NyRIUZb_JpCw-98PL4{b9r> zw#U;iZ^?zbU!-ke=|b&=vNt`ca4n)CXW>Vw6nN0%ce4wp2}F<=>d2o_{ly+|#haDn3`<8vDV@`aG;tvfWQ0;<{%5MIUPfgD;3YLvvh*r8%DM z@w&r;UkvXe6&DpmA>D-?-W0?28K@&#VRsnac4Wy|`OKgVrRCTamRrB}%T}Nnn9g$LpPFkLqS|+NXBXevjpcH)DdJa^ma}E?jLeA9Ck{e%+=Bu1Y<`HBr1{h+bwQeYC>-&0JpO*8S~o|zKS|AU z_>3tQ=iq9Fb1-&^y?b;N4)%^Ibi4?$gd&lEGvJHKK<`*!OyIZ}>2?(aR^aXh<-}#2 zLzJ98k*ZL)xL|ZCgL|M4ggw;>%H8v*vbaM?x^-v4f=Dhb3JdR!qbSZHK6LF7>Hu~v zam^K8`%I@@1!oF<-)kJ!-q>gxhm|({U|mf=SVhwh*39%1hadMaH`t-M#0QczzqQ*Cay|hxEYWmml=s;@?25* zbB$En{c0aWKp`faaYr%Zs|0=zd-f0YXU|!|Qdt1Lo4j;Ix<)r9^-=GswFJ=_z zg+DNxO1nH{thY0L7MuJoBfr>O zF}u;>I`Ex)oKoS-&Q>aiK(6?-&i@keI!|piR;sVm&C>>29g%((S8AlE5ZUK%i^y?U zT!D2SXPJ6jaa?K z>&-hu^oE*?ly|CJX}?O3jN(j?S>R5`cz_c}uOOrSbc@p} zkD2R18ohUY6@}rc2Lai4ngtH|i|;63aDh)`<985(87^R($;5jYHB*!2oQMv`U1-M^Bpcr+_kwUSFV-PJvh%UhQ=XDhP8j?gfSUsbMqs|vI zK{-3f)GcPNYY(N(%4ze3V%Paa23PlGa?CUdEQ0vG30D}N+u`%ED3#X{49-o(xL;*M zOo1zXnQl}luth1GiqfW1f!%B4aum2aL&)V<5Tv_{kyM{cK!K|+xdf6+NqLuG#k&)RxqzfynFU`gBj3TgIf-83NWX--XA+Mi4=T`_#h~{)G(>>L z9Sr#+AZ$*D1$#p>Avet{hbwEW<>U;WqgeP1?)PQ& zyk1#7H>KH8!DpbNrCMS52bB~*Gr@}@V2=8qs{I12a%HurzJU6>OVF<-9hlFEy@OH? z!M4XBKWp5Uy1MA$Z?&d|ZI}h806XqYj1I8cnX>(MjGoA5T#yq-Mz*8Lau2HJ zF*!ywdOBO&i?Hc#clGa%ypI8x3nB|T<2XeeiNa5aIXWi@MHQ7}u}9z2QcaQgQWRC- zbn8T#9H*Km(quTyYK`rOZ+YNLXgE4x!we(DHm}-mrVv|aGn2?}^SVKE*}~d}CgOc3 zw-kB)-!9LR%WpX7gWt3$`74*7^3gMY*8yt>lA~`M(k~Xs^z=EU2v>hN#$uJtoQ zhbvvWq2lFvfqbJR={XCXg`+>E3y;Igc_dxwc6{h*7b-R$sXgF`RgvRWaws97OF&er z`MLVT>F7=ASWM}_=9DiTGbkooRoGY;mkZmc-mBO%lZ4+DTijSxO1d95O!? zK#8{=`|6r!5k+Dw`Y2y6!Tew@p`uegZ%GNppH!QMFJzK>_fk~Gi7&&%FJCW)p=b%9 zn5@{|y$lkb@3K3s*M4Kmlv?*4u5^}kjxWr^%;H@{dR>*lKdhDw^Z(o)s(78b?1Xc;0nqZPe5fX;|}Ds)C%>t)E?|9B%t1xA}A zEQg&EY45=h=b)Pd*ct^+zuX&nyC+H(cUmc{ReXGDrQ&-qt<(`!`IkEC6ui9ztLsgH zzNXZb4F%llC&SA@mZV)-KdJnGpP084--yg zCF%97R-RwM?+h#%DwMOQI~v!JJr*$)ie4qt1T<>8{)GKbq;z`8YZ!D=GIY;t5OWTu zuXvzoVU8luHC#h@W$!xS8RZ#R^M;z!a|4YJZy!~nVX*`XE#)3}2Z?*mp->|qZ#RQx zKb>D(m(yAkCJ_GaVF|xWVK_j0?d6k2G0~(-+(wY7yzG#G(2|&58!wY-s;hLU=ZxC9r$&gyK0o1(` zrnHa{Q>azFW^VPc5_wmFjuTG#AIeV;H7Uyw_bT|3`DGEGBj0|Y^1+#$Cy^=Ycp#hI zeXwVyyHC<|T6dqqk6+P71WT_RV!kD8R=ej-aLn^J;ip^(4<@W=Gh97e0Oz{kY#?QO z;aG$ft-f}KhyC)L7(QbkS*8UnN~ta@0M0qMxMNYpLQF+lp>?c$1HiKl=06zO3|1=N$Gl#QuSJb`!2=gagqMc*eAo@)f_k=r`YcvT_1h<4F_S z3Xy=#ulk}Pe}k6VX;kEDOQSV?Hf*XtA@FfQghSJG7|GB`xKy z&a_nExFj8|;N1c*r^b;Qiq}plGI*Jkaszu z??pvT-c78FRLzwu%}?oAa?3^f#+G~+_ zhLyGX<7$7Xvj>`NFV?{+DPf}%;I5vTRYUBRx;3Zm{XG05RU9RnZnnmML;RCiMyJ#f zA@;awpcx%taK{NDm;Oy*^(g*R^9nbiZ3on*ryPab*+?Bh;k#@sA>%$Wrj9B6n14qU ze#XCp3Xk(|pTdj$+pX{y{>|ekXX9fIkvUCmuH+nio-iuIR`?IQ=Gc&(%Es72dgF0( za=Jax63c}Q-p0u`f3!~(CV`HmEq1t3RIcO)| z^`>ni)(SHPSym-dQm`}WbbpI(N{&lb(GD4LgX)dpJ_l=zKdq2eye;)2jgKZ*FmFj= z>F98`gp*&mzZF_6X6!;;fDbDly9+qyu%^MxjTFbl)fyp1L^bjCUm6-4ABbi{uIj)h z>ad=GXGiX6En(Wh9* zU@?}_N}G)40ZLd?_*OiindWisiI!k3cSx+(L2o4e8WA!{4p>LCOji)iF|=A2uWlXru`-&l;4y*@_$B4EKKc#f$n#QaFKQ+Q8a~bu_^AT*gZ^ni^j}qUVbCfNg zxr3H1dERpGtyq@q>r_P}@YS~v%W_EFbDt*JEH@S*nq31sEGQ2_j=GjJywC zU9SkExcG+|ww1{E$>Ms0s~avm4h5$mu&bk6MN(kcf+rgM>WQn8`V(DQ*e=S>t^q_F zj}87EI~WiSBwBo6&BU2#9)>H3sMzQEt+X=HV5ZMM_Du7B8fXa9{%g0reIWoela9hQg;eDBFmKAnv0X34P{;dv%KFU8QE7JiHghAxO7^5$Wy>cO<8g~&w8 z^tHv*E=46iW8&wCcrjgYgve6gN`1#(staXrAnTr^GTFEcgKmf5(cAOIzwA_cb%Bks z|4|2SuRI2yh=5YywFpo7Kn8>hK{-HvCABOpvL-J+YbW-a_~i_)oieXAUVz-C`141M z90uOTqRxx{(Q$}WyT$FKs$@x#Uz(*fzW@h3rV1%4rp$KYIWU${!!XmPr}Z@H;3aKZ zMop||dz76RpQ4|V$6((OJQUYNFy zX<|o{rHLk#HgA*EM@AH(>>b5q#rEzupaa({{3~=^)JTWcFri%ifMaJ^;&G3s1(II& zrXZg+Z6Up+)9XI`?wBkiozHRAr~2(C-`vx%e+*ps{l|M$|A!_-3A!NuK&}@c$E6G`S|G_>%?Vd@gC>efQu#7#PvgY7zGMu2 z_{K}T49N)%wQ@xL4O@=YWX+3w=)TSDWBkc1TF3k=4e>G!^emt`(m;RZX2?cix2?W3 zbb}~9h3ZYiv*d#HFZx5i)o3=ddMr&v6QoKGi}nG^^7KE_9{JAv}6m%G0j={l{b#MjH8?sd746jb8!m#54FMTo&SfY z{I?fQ3+An2z=LJ1m#r4OfoJ*xkJzR%=-+{32J2j$XR<~v&P(~%DujE{@Vu15|5PCR z!x4xJdJpu6c@zp&GI@=#!xAOC0vcv%2JMG`OQnodiz_%IFf~&j`3w@xw;rjBhWV~3 zm~r?_^Bm_+kl(-O7wl6CdqF=3BF~aS8}&_<@Y|U4qAYyx^@I3aZ!%Q@XUgMx;T>P} zJSU)g)*vUwce&?29Xjx#)beRC3P0=cKyv(TF&S1Hq8^l5S4Q2CcWTH>k_~xjhu^s- zjzY&<-s~>BYRgiDj~(G{)O@cSS6I1cD^JN%^kvG*-IZBG1UDBIBatCA?mdBcK9tx0 zil@VZcv2Pzr&d()GJ#cK)5e9Vkf38@^$|mkTke^`&<7 zp6GZjo|6bdE>UHMU@Q3)tf=#12`p&nE;7|M)4WRO@ALhK?&Q?gO1H)HC8;&zWi_Sd zKLa}bP(XAsl`kM{MAMcqikjDM>RaM$t?&sWe| z^fkcGGSTcE5*on0=nO22$%^gW8{pS-7ItCQ+SL7GPxTy_zsXlgOJq(E z_O{%Z2&Q^|L+Gg^ITExZ<~dK^ZK+MMwRC}uSYdlE!jO)W6?lg7EsUvELePJwBLZn* zu%bj2Hr|e^_BOh{G`mj@D$qeV(%-_CDn7mpiX=O}p}Q}>gBrB~TsNP-Bk{lr-6t9)=| z#iiz(N$_#K>;a77&O(Gnj-W@X6nC6pl+VEnb1C1ruX0%Aw;jXe1<`mw+!v7>iSfNc zie(f=6%98Ejig`0eF^b`Wizr2w2Y)*j1iZmEmj_A1%xBdf5C z=Ngy{iTX0L=tSw`aX$y~re~D2gi5QASuD(RVCK23rz>KJ39Yh=ERb^}MY~1HlaEpg zGvGW7X)^z?6h!Y#`xuy=H^xn@G=KBA1=w9_8I|qjr*7C2;Oi(-owTWu8jN#jxF!{c zd8~5fCMWT7uY5-+4xq%Lb>W6_G&Z`wlgD=}y=O112+vS`hbuUzt)c1)cfu2~6D6lw z4UyoYACMo#WX1OGEhtZQt-7o-uKM8?9we;co*y|U4Ox{~zpK9IIxO8=Redq|xU!w< z3*Qx>w%|N>(DaIaf+V;8nh4n9#!4rZBL6dK#pb4hY2kDbH zNIWicO&|9e;>#JxT}aA1|81X!o546-DNjb8zS6l3c~2OUBK`-zX@>kFK%(IeMQZRx zOa6UWp}gvX7D&`iQD6P$DS4I53on%G<-mRD#Wc)Jjo}H zCvYrI9bZIFzylsau;)%U0EM8FY-C1%?W;v~FXJ(WuRzavGaq;Kn&fbh;4L%UifGC} z3DTlc!K=%65aDgu2#HYhacTl-4lrBj7vR|DZ;m*gVduZ;PE>I z#S=(%m=|EY)>JRmW9sLEVp>rSp-ff3UjG048?5|!f2ms{eKe({--hb9r~1uSzt}Vo zse_#Sm7Nslj91b5rZ@-Bz@DC#k^na`1LM7xqBej)X$vOBS(Jl{HY1(PG_GX8AWuuD z(9vWl*KB;XMGAcr6pMJx&Ihisdh^}Xz<0{gT!Z@aaQqIV{``S!wcO26HIaX2e&<8F zN6kbQ;gSHlb}Q1n+EOM{(WgV6HYk&c3WTr}RN+z5q`sJk^s#Jopigs0y)di48Ukrk zmkuMyF@k35ytjhg`Lg%#~UlT!>OaFBYgYuoP*BbL_>zhK8)#jy(JFg2`=K{5k?L<6fewyo8XuJ45zE- zG9%J8YMBwGyZrmPf_k~{W4~>g5v^A$$71xDa;$>xlk>Hn0s6Q*sMu&QKz-a_zzXgQ zh#`)e{>w#vnnLwc^bj`~=?eER`WwCi?8bz<__doR{6nf9c)npDM^3PM3R4fY%*K6S z_h4CcAK>1>?aI9qKarVOxon0ZMYp8~KuTDY6uKpn!_11E5k9R8`rn6dp7>m_noy(=;#&>%h%j9T+ zy}D1Z4+0CyGkoiZfAK9JI+4XC9Cg6HxV;5wppHJq_PCalVzi8}u2|)OdV!nm$m%^Hn8or7aNubD=oBz^@CT zZ_Yl=y9Rj5BgZcXetEBf_GTWZ*8YZ`ZZ%Y?bB3fx7CujNP-+Qs+rm(@a`KYKe|8eYWKnKEg$`u+)H}_Mfi&>)qDckaoXKo4YyUlkIaSyb@A)qtU>l z%g?Sc?R>ts-pG=2rJ`R(v)Vh_?5lVvIbpb)BoUt=r(u z-A|uherx=h?{>|qyTkNy^4Im(_51tV`JWy7D(FsL+xAbqaUuJ=%FgcBru1%@*d*|Y z(Iu5%?{~qk)z@|B{l05fi@df)2YOleUA@=x*fT-H2e)mL+r0BvkF>pF&M!9g4}WUv zQ=gxnwln#=cUOPY=e_49|MK%5QE_A9eCG}Ane$^l8$T}lu=VPYp0BKGvFXpW{a>%W zH+Jcag(sdqpuOrjeSCcGj-%_UedYeep49F_t^GxV&xRNO`bDn|xt%wOAx)Nl9=0#z z`;+h1t@Y=y7M4N3eAKdUt$BYtVjJwuJNiYFYrQ-D-TvT(z|gZPBe%b>rqbbY>#H>w zJS)d&5%K-4Q$1e(^SteY&iP}512-Pe9e=G=N%xC~ThAVlvtn(>f^|=wIQ?P7yI;TZ z!y97~d%vjf{?u9}b;7Lmk3@YkrRCw@ZLXthx-8oMY#YyvZH{#jnfjPRv0E=U+;Hr% z>3tiw-*M~tWwYLWveen~$8q~}UY$4e{{BrxEw2SuePQzxr5)~FK3V$D=S{!gHD^Tc zg!Vh1jQL~cxPu3WR?V&7d2&+ZXWzZn^w))BmQL$3Wp&pobKfc2QMmVXNxxew{A1TY za^krropPH{J)%F_uOFSAk(p5=vsQL3vM~!xa>aAoG*KCA&ztx?`X`3zP9qBkJvES) z0b>6~U0lb!t8$l4Vsk%(-zcrzvP)|$qQqYCom1h~WT=PwGWtUm4(__*?NmF>BmPRt zp-oW=9ZM&kAAW&)oq~v*_LJ}YqNR(+;D()A8b_$D^RE@=>G&T@Z31rev}_#YAkO;8 zo%B9}e@X-TU*1zfyJUNkbcIBrV@YI8W$YMI3pPa|y@4fc^8(|1phIjASpoYiAqRms z+5SGGe<XfY#tX%nrAaE1Ukg4p(}u!fflhRltTQF@pG0r%QDwl z#t0+HXrM)8g;D5D!zjd2VWe|P82OzYMqwRb^D)Mp@Z@mZZ5EEjl^7aM@@E+LM7$nh z5sjVXcSj`I*NGx*&p42=X9e;#K9(>nkzAvI4iOIw6a%Vsui_Asllvt*#D%zi$rj~xt=H@*V1RmX7m`sPZ)QOCD+oaRGJs3QA&SiTvOV+ zhD9`aj&K#@`sc~DY+ z8>M344yqxI-XT35-XrY&9{JkGSaWaWUW<7B1G0biDA~Vxboo)#@S`Vy!C#O~I%6Bg zCm1I(zRdU*<7Z!xo{NmXu#N2)`As@Tn(G~VC%e7g{us5p$B&WbiNH{?l+Bx1W*?h( z#gY8L&4hn8B|O45sce&XoNCwb<5WXt9iM#MB3_2sBEDoaPEg&BWXaeQRCYO4$+Z*P z?AR0)vPnF3g5ofNZN7qyMf}95u}uSDpeR1^$rflnLFTtkbgvR9b~ByB&*=L+2 z`__y-7{>!G;tuOM3zz5o>K4CnY>oDdr_WqJ`Z#3f!wuw1Sxm5Ku z)t@$}skS_Jn(}ibY%JpW)3ri=5i3sP6rU7 zJFs~)&?4r4)BS5hlfGU)OE%TcQI2&xN3Cq~ISOUYx$a*lvy4;Jx=1anDPwoW>5TIj zmojc(e24KkFh*Fur4|>;7|qxZ=oGzrlD4P5CEUn(5@-<{zoT&9`;N+S+a-#B(B%~< z>-5XipG?0(Eoe0`RMfsorQh}{#Wv{2Uw*KNydNpIpJbfKxR5cXJ>}b`AA8quh$BCe zhKoS-SJx@5p+JY2a-D3N|3o&Mfevx$C$h=-nRGV(nL;W4h0LoM_W&It=?2L>exu0^ zj2etHZcy8Koz3qu9%H@fKn5ZR$Uty3OqZW(<02wBs=z17anSj`35D z_`z6prDHK~2QR_M-3f0}+HoO3ps+&nDfl&uia5@y!EGcYaqk3}0XKSTX2y4+3bCdP z7TC#!zh+>?U@KW?OWq|67H@zh!WXZpaEk}AT!G01B;RNDsF=d+5LhP83*guT+)glS z&(ElXaf1T+>mX*a+chw|=qToK;%U4!J(z&8v-SY zMS$7GG?AlG+7mQNdnvv{Mv|FYW32$J0ka;=ri*6GhAP&Y{Y_G=1GASE%V)_=iWM+B z$ZVGA#q1ojIe6Yj;oVehFf&7^(C3OG4OB$xk0X5x#Uyr1Ww*t|;8vgA7KCN~8*Pjv@sYp_nqYmv0>QSk+gLEW_*fj& zis3fHSO|8IZd?c34t5yq2(tss4$*D9a68ZJ6S^-G>;|*X=;i>hyUdQzyX0WOCenG7 z-u?l1f|#*I1HI6_={nunOpA_B|? zHVrIZ#DG!E=9$}IgQ$kKfaCHCm>p~(hyDgwZLOJB35`EkYyqpUwa^L-O5fWYLJO@Y ze4|ZsJafTF@)TIO_NeAzc7x)nwb2ThX%@+f3<^CG45x*((d!N^}5Np`2n>L%>c7a8U#}zxulD)Ng z2v3Ob!R(^1wuD3f8!T8X&`uiE*9Bu?VHc}4KNF=d)=IgwNpqPfCvvP5`X()bSxaWy zh(YpkYh!IFz62^+5wmykKJ`k3Hyez;WS4;)2o{UL>|nLoZ7sX)(VDT_TVQLnJz5^S zeavp}X}#F(IJ>>4^<}q9?DoDkfZhIJxA(On?B-{q@b+pW*ew=pjkZ@C#ViNRj<3{= zW7Y)hp!R`Q$}FGRhuUmrLzwN?<};fBc0&6|Tf%G>yM3f>V75fDEzH&{_BOLaioMJ1 z3>azofb;A}umXIg1N;Ao?_C?^?lJ8;yP54&Dqj;rNr!_)<2~PsW@0JKZff<+l=BV2 zTA_!nZ`R_1MO(1VIQ2A=Ss!NivUD23|0iK+8-pjEwpWmVB8d?fMri`4+p` z_0uf*p`B_$vR>6vg7A)j)z;j40}IucudpX>7isz;3&rJ6xFzEB)>4ZdAy^!3jCfH^ z-^gy^V2OH`zMWYtvl{wu%qoKgi<){624;*-V68-5J&{=hmTaIuYNha6Vw1`)8tHwk zR3p2<%`6)0!>yE}5AD4jcF_rpa^h)6Z^ve^k*LwZ;sr3f$k!(^Tf%IZzM0upuv{D# z+{Nrub{nq0%b|bGY>fUnyZyv$tbUwBzXxU(6ZA7I8Rgg8(OQ%cL(I~^O7JH1dFv{) zfTn)b`X}q(v1Au8JJ|Qu0K|G2b^_wXOL{E2tY9$}ZpHdsJ<&$v%6hPPF;}l*qcptF z{^si`Ecp%COtDZ;wUL(FtmS3B8oL?(6v7fchgmRKxVB1fY@>RX0A>~&^!7Aq5IJBa zV!L9k73;)q{T1uV>>0&+u+AA^;o5e+7qeHu>|(F}6tm4>kBjsA8|?36f2!9P^v%r9 zGW$-kUzlAchV+>OsEmF9qtpg73ogO)rs5ysuOjM6g$@m zxS2(LqZ&*051@Fq04s*%(_nUyXS85{FR{OT<5AS%V6hc$*Y$j(ogGa;d=59Wc-$yq zw+rmnSFwM1pFDF=XqJi(S;qM2< zDmy4&?gmo6Og2*B7A*82(lX6Rbxj(7;Dpz?w3fZZvjK9qbGi zFJ3Tm*{wgj%`)0^Tt){`+0HRKvfH!lwvZS?SOsPlON;_`+s1DDiNWndb~|7^#%cJR z-981Qn*2==wTB~y$3f-rBbZqnHAXpBB7J{C5_j2yQ9S*FDb^>A(a<799JABLi!7M| zhFgb>bu9S^yInBeaQGnv+2X!8KIPE6u-hf$7)$nIcE$Lbbq-;6%{a@c9T!Zg{mJ-_ zC8x2QFnz~bUSejLeqpv+v3s1_4PYgBAZ+rZ5_?;@*}#N2q*yS!eZ|aXYRv2svj9^E zW;Ye8Ydo!J!AyXCYzXZny?weQH^bkj%7x-)y;^f5Ef_vH41=@7GVmxwJi z9cOll*>cl2%z9oXx3#9r%ywTPw!!ohGns}>rr(*#G;B8g!K@FqV(ns!={B%?}N{$chlvt6e9<@~*4()_7ZWC-t?3}#ZxZj+gr3}KJST26AW2_NKuzw5tI z2>VR_%&PrP>_bx!vzM5CWC~@rgV_O7IJ0kIRfiQ(Kliua9G3? z%@89aN`aFirUPe2%!K{Ih?jteA{GLVMJxqgjaUWzEn*#Htj-O<80Qw)WH{f3{+7;N zFyD?|2Mmi@r%^mF>-oi7Vx}W*I~eye9%4)kA^VeTzQA~y@h8UHjJ66S6V4a|%qy;3 z;j*43s#nNBx*9UJV(bWv7lSHP!|bW0vpQz!BVeP62^AW^JiWprz-1Mh1K+IB8u(rX zisuQ&-zpUOV!OIxb0fca9pg^Mj~KsTyvTTiQB)#HC$I|k%pbus)2fv&<56lRP!kg? zZAK^yV2&4uE4_zU9jIwxW#3f@UTaU4raY5W>gK{#{ zlwZ6x?h%Bzi!m{T%okz^Z-f!n5o60F3S~iD25QJPnDdJ7u#Kb2 zTuWZ@+$vH<>s6P+#>VK+7zOmY?ur`+ zJ%2D(sXET5EvM=h_^K1N#V7fXdjKTsRvln6#I>r2Fyp_)XifP7=7bcQY5$x;`J<;2 zMl;q-y$}0tsV2-KpGc$B6$8DY|KqM<%P&q0A-oVnXsb}emL)c(HNc8@M`R6~!S&n_ z@29yY%2i91 zc+nt}Z2DwUyGY17W-p7+6?=Yh(=5VV#?FjA82dAhVk}{t&-gMBEuB%z4t8iFC;J#| z7Q|)4JTSW%kmBGCWmfiYNa=jWC5*2Cy{=o`?H%YDvI(~VHIbS#7IVf{In*C^V(i2C zWX^r${N$XOu%DYV2{J3${%ywhftomyGZh-Hc%a_?2W-mHI~w)scs;^zfnIz6sz>~&-V**)kMJ%quh_5taU9{O zSfBd91V%Sw8eMH_p%J9(!p};P{5YeMSB+SDaP%Rw;%o5Kwi1p7B^B7k$ zZeV5#H3;Kn=r3#j+|6u=s)htq4~w{H77j4_!$tsnwPa%XA3u6 zw`CJnVskPuUeswpwdna4)Y89bQ8UyKms`{e?Nr>Us0(#s|~=g)?0w- zt;fN>RqN5f{;f%Va_e=lU)lO?El2EZeJV6ZeB62=T1W5rGlM8)Y5qhHm%xU0Cs493D~v$55P3PU&6D*miD0$A!7fzYMnyFUB>F?$vpb} za^Uv!Z+F7FAfj?`ycn4m8WArhMr zg>|b_pi>i;&Sa(>ju#!f^ngu4m)_2Jk(d8AaAp1>U{KeSz#&~P0_Sx72{MPeS|Z6N zBvQ&#AO2j|yyCM3G@f2&{EhK0qhB|&PhzYA)I?+t!lpearB4D$Lu3J^4(HZX%@2y2 ziSZ6!YzL+@#xXv^Sim?Mm{)wDM=9`Z51Mfes?a?edmcS$?ibmUM-#?W#$gS}rcO@^ zw?)rhkZjkpf3$(;kAr}+&d6FMYm2NuvYyBhcIe|&1B)K7hr0Uj(YE~9`q|?&H|`X^ z9--WQd^6CmS1F~v7sY{Q-I_@3MKP(?Ydc&U_o6trWz5N@{2ADrB&RTvO-*sAH{lV+ zGZ?>WioJ{{*ya-BEntZFs841r)$mD(XK?ORV8h(Xz@@oEfYWk^1Bc~~1$NIJ1$5`S zfxB~eaf@h=k?U5U0nniL%?~$3c;DW@_`Xj7x8j-MU8nqF)Sh*W99wv3*zEA6!bZe@zzQ7#=$f@BD@eoXsbZD zSDGh~*&0t6%;sHjWIn=phH)?BDMlyD#4v^>l4Lw%6!71ruZiqp%B42Nt>Q7WDyEUE zgmGnYTiEPjJjM76ONNw?d`<~T<}rFoxEvVz-8yv^FmUQzV8<>ifpVU?aq5r+(mV>dn{j$cG0f*nNX9&QWqgP* zU%k_ZO4(9H6F*Enl0a>Q<{^>OE+&xcYkkXdJGgRw@$6}YOMvm>t!WXJvqVB^K6=_Z zr3ElQS~>+|cc0S7;QAEfgi?xs*b9deF`m9a<`Im`fuz4tKMI{N@!D;m=Ng%Bo~T#A)zE~PG=&9wf)y`F6DHJAJjm`}c*n@{Go^QrE=H=pw7-2A!FFK4s= z%%}Nkr3Iv|7Goac5JoxgoxPwD`i-p%Qh}!z(46-Eg4Qr6FQj!%>xGM;Z7}2W3uy*b zehy5tUpW(|6*o#yjVar*hhsDhuQ1#L%M}0e zE2->anrUx-neY?FZyDtZt4(q1WLnXaum7u^l7^5H!t(8OddU&A8rc%flWC?=z9p_K z=>+}fOUQmVn`LYLhvVsOrxb_C#niuLE+%cQ7gK!tFpgtfzL@G{ODDBKYJKq{eFj*LSXr!p>L+{$>E z@hszSjHczJA(pWkV^hX%j3XGQGQP~Xk#RTU3C8Qdn!>aqBn9hVjAFo!Xs>x7((U?F@$H>rpn4z@fZzPQ8~)C zJZ%-V=*6q3May>m!>XDXAA?rc1FkHok%|_yny|y_y1-GZ8vzquq4|HUR|dlT$Sdp6 zx3qf&qm2k`-y89Nbj@q9@3m%qYKW+QK4UobV9kJ@YX!j3=LwT9kbUz8NBRZm`Vzx9{(yy8M& zyqLVcf#IDa&0J5rc1vN8Ghl^}W@U+IHq!j(1;&>)p2^b05|}HCMKRRtz6UdI&Tf1M zk_n}jY_y{{sT|Yaq*Yb(H>po}?M=%6_unkej^{ZcZq|8|!ljjFyr{Z~`mt)8R=~C9 zrZ=+7a%>XX{(H>{4={cv&7CHpH)yo!5aio!Iu3kn6U`{b0KIrOAI00v59au zQrA7b-YjOQ7DV*H&^+e|Vx#z@ABjH!&7j13r@F?M3?#yF7iDaHwmQyFurlFqqo zZXZSF)odQf=51`Q!{$%e9F|BjU$Z%i%~#kQ&*oj6ikJx`a|ia`wnM90Zw~z9o}80k ze19{cbqirI5IbyJo&_dunFk!OWlv7LsIrwt*c_nO@BPh>RL?ISwUzK$#w9?E!dqJa zFK*4PE@y*z#gW^n79}&*Vrd@$KF&yjdT4@KZTfg72Jvv9+XN=joJ=z=Ff7}z%7Uu6H zT*bJ7@%=Qiu}vU!GFs!w9L(ljab!Nic!qH=+reSlggS(bbF}!sv@QCY!hKL%P>cW8mid2bTlsYj$h^)vcQPJg{OW6p|8+Ls{Q7^2 z?ezasf9RPaoSB!gjX5(5@(E`s2kMLI#--I z@jvLCf^+rd%cy+0++n{ItN+f!Sr7RQ`G(>U%jjmT{mop+$aEEa(6O~e5dOC|@_Xbg z)uR8ZOXT|F|LSTwM>5ZU@J4|}RMmR)Qy_WgdqV9J zX$WA9V7&RY>oJRnza(?uf7A2Ar6x5kV$mfR!uqfH2SD>})_MODnXQ*8tOx7-ER+$& zliCi|joX(g_eiF^PI6rkXAwuQP(A$qN|$(?UjC5MyY3pjOlmJC6Ba-)Ptp? zQGy>$O!AtW{Z3}-tHa@=aDD9XA3l^e4Q`U2zBehX@)&T3TW~H`X&Vyiiiaq5#4Axz-32+M%eHB{-w;(Zu z*#Y}D=NEVmT*T}n`#$GMu<=UrbLZC>y{0O5)p-GIrea#;6)jZES1dB}C$Qy;rAOY> z!o+KeHH-WUY?ER=A~ii+>`-iYq#10lV$&iWdW1Nr*h`UNV5X{+_5=16krgpp^H*$R zWM!~$#db#~gQY3Yx@a30QcP1CsLZfH^Ko zE638KI+kOPM0G943ZnX!W22*nf$ib&J~Uq75cV^hA{Mb*S~`U>MQmrCNAadPu|ur$ zPBqESb6gU$B>SD?azQa$G=zA)Kueq$s#qbk#EJdPrizJh!-}vbg-{~qGi$|c zu2>cQBIeI8Dz+6YLF`nL??*4h9Q{7Ci`ohJOB6PKe{jF{3qns6vCIx=)KZf~4zp65 zE%qQ-J;kcV9tLZsST5YEh&GD#gIg8RMKS6plEq_+Q9qF^21thb($;W`5kA)0s4B+$ zSPvsbyyas9jC668S&5hutLd4-UYpW>Kv12?#6=a7QJu&X(TY)B$`tX6QC-RuRTZQ9 zk}0wjqxzC5>L^AvGE=l-_MuL-CsW*1Zj>*Xc(O;~m5A9$JKPjo&g@QI>9&Dc2fT(% zk~?C_-|LEf5Ie%i6nhjq68kis=bupQu5BDxW+UnE%h(blTRf@Qw@7=Ac&@Q@`-$0Z z#qPyUH*&;@N2HsrVqdK~-BFFd5)oT*mQh2DR4lDx3#`8PC|0-PT%)G=Lb2u*)AgF- zl49*EE`-~kiruv>0SjmfjAGV8YalvG1}(W@1DQ!J4aHz)q~(gy zP>g3LwKNn{r9alvP%QMZUm>|sG8^@~jm36mQfFhaN4ZsSrNiwb#j3hi8jZyf#cH_@ zYLAFhinVqf20Jeq!n`vT{38i$Ep5&W-<+ritb9XKm0u^`YJXI{vH)W6x$fN z-e@C=6dN6vtF;m1CF4A6E2c7=D_X~QHMJF;TTrZJ?P)6tTX7m}L*ox>ZN*r{#>XE9 zo62mOZAN^$-cD>#Zu8=YnA(Y$*5q%B?Ui^9ZuOa!+Gtd3C$=kgGrky-dlWMgO2G~& z7Md{A)LtA>tZKqsurC#(@x6mMuNaN*9mG||8Ye6^<%t`LbxT+YcAwdYMqxq=t)tL# zWr|)*SZnGi?25gfun{a&F&gbVi5SIbwC^M;D@J2+XHi`-8jCxN2Fzr8=z^z4oOT{N zx`^4#Y++>Z6j;Se#Er{2egUY%O2ZWH&hmntF(x%%;HYW7A{eu8)0g>Mb_6qZE~hrj_3@^~bYdVsk}7v5%ia!+VhtQuCwhmHDQRUO7Cq)Ovo`d8dQJ6<=`?b22pV0^7iLqph;cti- zt=MbKo>A-_X5*Pn5ud`}5Yf6L`8%MUhTBllNwII4J*L>N$fcp;3B~>b8z#mpW=k~d zPl-|=TWNU2Y#+O58ZH+3*k#iQvC7AOG!=?BeC&p)NNn@5KTIRVZXY|WjS>fZ>@U-3 z@wt!PH$5#*``AhC8S$-;napFvk3MEMj}$5PCbM3Rq%>BXX%k7b!lL_Z&^XPzu3`&e`H6tT+3+MB0}y*}2>JWZVUv3}-K zT;k!4%P{k^qJxh;ZGKLy^sy52baBJSUNAo|8h7#fn{R$W%=EDp<{4sxkF7V)6rcLo z4)ZMWgO7b^o-OR$AP;D^#Lvwy3b&7)G0ze8ee9z7C6VuASIu+9NX3#+C+3Oqie-b% z7t@%@Io|>?i&=@FIo|@DC7@W(6}H5m%nQYBx};9b5ls?rn-`0y9>k`KK8cg`rQ#=M zQ-mk6xxQT7QmhyutPp-ZNpgx;SJf*NVN&_M=TdqpuZLl^f;D z>*AJT)Gw_Q=s56qKu{ZdLxd_uZEU@WQ;d4I4I)P|>IXN77K%|1wn5}8Mzh0>Vhl6P z;FEH}rYqJfsfG5YSgP32q+g9U#Rg_m#3)E^7LU-Yf{2SP@v3=?$W@GbhOMH9V$?Hi z6+?WIW__!e@U+hVuX*~H@z#K^RbiKZn4wHOy)h}b04#t-xHU8EYSSExa(sP=Di}mw>K`a z=6#~JkDW1pAlms@W%Gw(u#csf_lp@mcG3KiSj((bOiVgsJ|NC1HX|wC^s%t?5%?>` zjI5)6NCYw~v5k&9V?HDzr5kG28S^J3hQ9;mg-KbKPbC3cl~m7i#K+!9YGpYlTCu+a z+V-UOmgC}4$?WeZ9n_ACc8Yzn+^cd3gH&1z~2G$j4B^m{u0;AY57~+ zlgviBdsk?KNmAzSU14V?!@Db*m2>+?v{7yp-aq1zA>?n4__j(#tI)|yleFLw(rs1pL~B)Tw_;n8 zr&?3AWrZ>>6ndJrftd_FU3*J1+v((kTDrDdu^*BTgMFmfUASdvpD7mRJ`8qBGF~xM z)2=d;^}3q2yGVvd^(9;DIf~dEk>Xxyt*MP?Cd;U{wn4eob8oQL(N-xo{M4kTbv4gu z_Q$zfPkWY`456O(mSPk_L#^4QqaBHTGSF8uznrYJ%djf9FwV8^If?IQKfnw9DChIM<<%%t-y4=!2TdUZXs_$7_ zYMT`Mtm=ngI~A*)a!_lfol~q;%3-kUiWR`EwHEq}jM-4QwbtSkD^9s&&DB~cwmjuW zu+EC@PWjFHs5VxylPPz=o?|9kV;k*7A2aK1v=vfPuK%>PK4#Y2YMXtmh1O2n>0@TS zowm=%qHXQ9Pkk)TmZzO$HdoB3l49$mU6F3KYH0_xeC-#-8l)WtyQA2naO;Z0#WJ-8 zaOAbe*?7XlGz?hPu2%&^A+=?AJhhFixiv4ZfltBx6MvZhvY71 zCE}0tX|{pdQD#%c-SnBZL0as1iuHcs$iT`*tHrETL}bjj4bgftD-o447TbnuGZjmP zS%rN6S4jq)+ z2>2_~b}+;2Fk`cAly*@vF*#$0ZM61}a+{U0*Y=DSJdyL-wlL!$SfXTNb;dEUxJm5B zB|Sz9XC}*NjOLbZw$C$e+s0^_ie1k52dqswe`7V$L8H?@84mkctuwpL6MofV?c+5| zF}cYWFi8t!R%(l`=Flf;PQ@x$3j=dcA;|-Rv=nQdn8_YxverW~TW+;v`(&-3V)@lF z!46I<^EXBNotgAEP5WCi+Z2R1O*62Zq26XD!keb~E4C1BrCPXRE8teDRa9&(+@95v z6x$59XSJvo%EEh2Ys#!d?5g&t{dp~qnGAiV)=e^7|2R#bsr6B8SezMb&8#vlv$W5d zNq;YDUrJ{4&+KS_Q9G}gGqVSn|4U{5=4iE;Nq=*-t1LN3bUw2^X0Fyqy4hN1j<(O! zS~4rKb;&FN>)`W;6_GYxx(QEa3vGecc`k)eBF1FSv@g)=FOY0X<`VnM+D^q@1Y4|S zES7Go;ctmHRI$x)TcWjDBHiB2Ty0;fZC)nXrvcQs ziBN1^)^#w_LACYmti`rhwL|PC>*s6Q7fSMC)}Qv*w67HVHOu7qe^lLfTu=M|0PwTd zr%6RaMOmp-DurvyDA$UcWXClx*XE{Mw;@|1^O6x+S>=Z8By?S_aji=(mt6DOE|=f? z^?tuP-~02I=i~KWXLdg4Jr8Z06rlm2yzZX8z~~C==eTP0{oCGL%nHGSLOp zjv951E&Mgq6wgLP_o!GYTY0NoS_-XU8}GoRbq-puZ{yuiF+pD#+xYm+kdj?1+xZMC zb{6FGiX{*BMDUFT*oH+R=ZGRu z8%XR3KN9s5i5=l*q0W-nQGP4xCW#&8%TP~9>=^$D^_j$u@p?Y1!9KLiIL`Z`YK5L7 z>Vj$!df7O^_e6CIy+zayH6*l*FX4xx5<|<0#!#h@vu=%Yl3%nFY9Q|}LMx3@z7myB zMAm}Z#bU>Z&hX1ozY&%5uTYOepBv}+q}`A*i~A?^gK>ecKshy)EWh%~9$JdlD7>5H zB5#9g5#F1q6RInTUE;e_rE5dOw-}fB7}VtOe4@dq7;;Wr=0~E&kaOZPKLM5G6KA=? z&p@s5`I;yNRqQj-@*6)Fb=fD8XbBbD6Ic1yRP3C;#{Y{c;hew5D|=xZ*m-@O_oQOy z{B?d4i*a$y@-4sfyQoUJvCVkl_o{15p3&`u zDYy7BRHYpB&fVfyqo9xP7GI8nKE7N0M-=o8-r{`=q0CYa`UY?DaVY5jyT#8#LI2+^ zem|22{o%LxQWW$Y+~O~yp!fe4UqN+JgWmsJ{8NlUkNa)@0}6V6Zu8ncTDt~4?zeeI zCOQt{Ht$V!hks1=%Wb|BlkU{qkE9%fYDcw*3if=Np86WvR6zf|zyRPffwMy}vv zO_lR^`0q?f@*n(aQ*-6J{2^19`Fs2=Q#a&4`Ol^t<@>y65!-|CX7&N!#?))6k{^PC z_fik}Bow@}ddROaQ$Cj-@<&X0$$#+`rgFqbJbA@L{=qifmmc$VOjXKH_;#jr`6(Z7 z>L2MDpJqxHp7Wbb`N)6sr%c_EUhtKs9!W2G{XkWHcjQ;RkEzenYd#VM?@izEV^Hw! z@GUz=je_@z@A$t^(BJW%*ABA!;BDc1zM-iC=^s7{1@9F<@}p4D zzw(jKK*8I|kNg%Cyq)})KZAmIj-U8S6!hSH;@yg&KK4xei5Cum(zypMmTI5))>O&d zlNP^QKJ$O0-V$+wb{JA7bB3zo@i`!X;D)ku3NhW3e`0 zJhP|*{GS|6>*@ZlExOQ!#4_1g(Ik3$u3kBs2$gnLx!+<=yqvYp_40%GahXd-(du7qiN z%br%%gp89+DO9^kndVddOjW8+_m3kfAEK7G9BNfv&`v?hQhvG1Xe&n{fJt9R+UX=j zp|(+tz?20oCy>}Us&uZP0Dx{)Lx6HS46ZWAlv@Eo$CETOR)^4{vX5}da zpN4#(GOOA`nW+m_b%YjYs$#!ec?t7O-Lvu*;QQ4q-wUg{!aY-*bv+@byeej6U0*0S z$jjQ^Dk;=>g}eQZ~2t6_QM~we}Ovo9b-sFL?e^m9o2a zV_}J@IO_mGJ6{zWVI3$Wn3`lABs@2jWZgsZJnLZLrm3aYAwu_Gt77Y{LxmDk zJFJ@u4i~Fp`>ex+3{%Ig!-bEg&RI7TqApdXylmZESZylbs)gWoxhi(k`U_!8)5ZtRWaSBtzdPvO4V%I2|1=bZQ2X9uCdsomJMw> z2z5;b*hC0^rowGH3ZbT2+jJ7znToRMEJT^=Wz$9IYigiPq%hpnXqzbE8&eZ(x(eT! zO0xM<$S}3Qrkk+T)M}gV!g^DAHa&!Grgqx&6bel3v*{%qGIhu%S~z3sv`uf}S5v>* z^bu~Gx@Gf~@YvK}HZj60Q!j1$3jFn|z4X~8RR{gmZ09YOtT$<_m>lD=T?5g2w^9S>3v(hwu}&psM5K0tybEO6w0Ww zxcpXYi9B!6{lXnwJ3-ifo7M23MWF3OL91Z8MPic#J1X+luhmuC$wGjs+qP4LE>!HOXohcdSd&X5Mb(^ZGsR*b%)nl zdkKj`G{)++4zWrU;;7i)_e7!M4=4rxIyJCM6y8w5vtlD7Nigox8i?*o$%3;f8~F#J zfvL-UiqO>5BPmsgF!fqW6MCC^E~N|crX1y2!X#5}a)yvsG@!~NZ}tN0776F?LoAak zY8`HuC1?*oCj@wcSSr|2WpgK6x3XI*IHN8SWeass6|E!emI=P7M^s@{ncRogQ6v^z z$!gHr^s`$bjG}@uQO&JZk`EF?40;&7gq1=9YKmv2yiz#NQj#~wi>+1(kN<*{Cj_`2 zeiS?(figMQHY4qR6nawK=i3ENv|B3-qAKOu1rF76gt@2&ZTy6F!g>_^%33EJqDm)! zwP)C^6V6iI=f^ht-fq2c)l|CO2BGF-sP7KnzRd!=T%i}$eSUD8EW1s@w-}q$W~JR` z;YUM3u}vYB$>Ipzx0BKL5U5fPJyh;wjV)3bQ{fj6xl5GgLb&Ohh$o+uHt^kbt_| zri1-)Aq};zT^IWk!UEK^c0KG%gk`86?PBat3OT5#w*Bo(g)OM;whQb|342f#ZHL&G z2?tS1+pq0U3ni#V?Z()j5q?IEZT7AGS>X!m+qP5e%Z1yhgKfXF|5>O+$?cNt&k281 zrE7fqH2YtK_b8Y43y6egu@Xlo!pX zQRv~gWD5F1t_Xe1lvnM46UI~B=ON`);T{T7UKe7X)3#{W+ItB%gh5ov+N1WB@(p1m z#{O-8+y18TEyip*{7E!}#mF{1w*TF%eN>0f_P0%a*Fmm!$5ciKOSQYEmUghO_NTCj zmC5btP_tU4aFyyl52ZX5-l3qBM?&krp`G`6$oE9(j)F3u3uCBYe@5^xgh@==oepJ0 z38+^c%8Anclk%l7-&8sOQdn(D7G4Rtn6Fbrec`pR0~H%_SbZ%NQYC8>B2Ew;HuJ4f z-Uv5L`Bi%>Ji>ghB05xiFT6xqb&MqXi1O~(v)VsGofqslgmjD{3SgpJ^g#$S6`2oz(>~4y8pE5sg6Ah&oRHso>Z&*ZrFMNrGzR6-^-Xn6gcT1VUvSrtL^DyHyTW3#X{do+b)p5R$zAQp*VwaB zXs`5H=}a8dJ*kH9q8&q7H2F%m2?duDnXs=+Qz|Je2Ti>wIk6-6pVJY z5v^adcEV^^8?hD&=C;_14Nx$*#a0}Hg7Ld{;$jqx-?bBSP%wViUMxky_+5MP5(>ue zRulh0!T8;3qV|T>4)b%Wi~cB>pHp3Ifr1gc4&o3LjM#M$$D?5Gj-!~3g1I}6;zksV z33d|CpkPd}lXw*cqj_tH4^c3hw}$u%b-!yFUsH5>i!J-IoTvd6d**W%Td^3uj-174 zOgXIED+gzB9x92*MLb4TN}ozx#d9cl$LT8GK*3uMSFsWW?>Jq>*Hr8sr>poDWAKjC zO_bh2%S!26O*he=3dR|Ka3G%-MJY7}$6Df0CT&eOjc7dT7*&f8P)ag)y_+kEZAAUq z&CAh4JVOO{z5|k{_>4(=+pU{YTYQTWy8AfR7F|9ZXi6c<(KG{pmK*2j>FEI}V?~J{~G8DX( z_7a~{C379SM-X))^K4=J4mq?VwdYApainG5VtbkC8=|_Ry~6Z8Q9aQIHIJyi*dDc- zsDZeM%%X=fw-GfIeaX6cpo647AMqoqjKqAzN(;m?xhvhjbZjKPK|Sdn?dT_3kr|wj z?-fbuFD^pqJ^DH}7OkvV%&o^@$3W2yd7ty_x$@ROvq*s`@8ujDt?Y+XqtF%mZ z1vC@yQKf5{J$Rv+_!zaNhfMSub*zV<&|Lf%b*V>=*j!X>pe^azgC1pk3(*GkzDGGx z4V0zlBF8U850q!ml|&6tAw6>)TZ#dw$e!DX!cl{JYL2bMHmI>Z_YiePt*z1As+Bm1 ziJaHPBo<)H_H}B{GmdS<9yFH8-M?Mv(pHQ{xmLu6w-diYeOb|MZ6{vFC{{;yxzLDZ08-7x6HvVYD;RDO8JS zUWgR0qPj)PME6l}2a6KlqTmh|MHaMzEn=gmx{BvfFnX%H*sL1e^Yoq-Eq143DWkzMG_m{-&Npdl9`gTQ<_Ezo?LvKghG24zU5E4GP*hKy;-l)uEjO#0D6H zb`B8Zsj|5E-s6e(U<_J4P<)JnRu2>#lXab-259v_u>}fRJy48d;-S@p#2FZaRu8Uf zwS2Pmbf^DmZ13q#L(EtL(NI$hiQ-M=5Dha`+&jr>xTy=hXFH8F^`Li_(^yktpH)ud z{-gCy<4xK3$#RK3kopim=`uxi-lea*${lZXayJG;u2mwqd$>2nE|P zLp+ayZTL>Si-K)P5Z|C+8)k|YvPK>}ZNoMsiM3I%4XI)X3br9#>||=a(=0I#1=}!N zOf{9{G*{ftq{B8WsM;dAU!UXu(HQcv$%R!h>*PM<-G%rw%?De1&S{ZYfn`FzOwmHt z?}K(izQv+5lMeZ^%u=@W;f4RH@c-#}ANfDAUr20;neP^fEfMR{GNJbCPD{m5tO3f* z7Tckq%xtkc3d+nD2cV$LW#VWQl)22T0ml9;H|6%#e^vkgDTr!1Ed|Tsp56f04X zZ>9JM1y|}y@dXO5&6VP76kMAt#dj#UHdl%tP;hOo6or~_{7UJyxk}WTbhtKGi&j)A z+Lo{0JFONSsFJn)UwtO3MFp+??DV7P$MR{=&NX5n)qNd~(HgNO3XahlF%kvGXpPtx z1;=QuI2;AXXstMj3Tkkwkt3#J4EFUpF%t#*dY!li1^arPxD5sSdYxEA#rE|&@d#D2 zW{Ig)W1Uz|1vPjPUB;BKKi7*^WHm*yUo_Z*>%{;nxDWc&STEjXF%Ir$8^ljk$(mnG zc#Vys#Rc*~nXQN%s7f^`Ggs_Sb)Sd(M6Ngr1^0gX zRHbxl4~m&o$y(=_s2auM8YXS#HAGx3b{ybtdQ$YGD%IdBE)|EPpw*?~L=?2TR7^%e?We>n6x4o7 z%%x)Y-}yDqiwR_fO^8`ym(~1L ztVFpIT@q{7X0b-G>uO#R$Do?T=GFX7EUv?1or!LU%j<*KsQ=sIr3NhaRcv9+yJBTS zrWCi6H7muuMoc4OFV}n`zVl`JKK4efhw6B88_M4TKbHd7?&ej zOEp7SeKX@O^EOhmP*&#bxbK{8rS4S8-14{x-a+~ewb3`-*+IHzYOb@R)HIBhvOO-- zxrP*tDk5^0R#UN&POj2VDEOV~Djh+=?^IXm6bgRPx=O#G;8&}w^cxC(wYo~TQShtP zRjQ<7Ya6&q=fhcBj*~5Nl?Hvm^jq9AXE!Mc^)T)N?a0cAv|$Z9)qCXc7Fd#I%TrY;vw6okwMplwMLiS-%MKZKitFm1!@PRd=SN{g-N9(iqfPB5$b}^@y~rt~8_v zOZk@Mt0&Dx@dH5lC=1mElnd2IR9&j5o~)EMRI5?_sUA_4((z#Rq}sh8<$WH;$<>p* znRFN@S5In*f^l;7q^?xy8q5T#C-p|bOptog02IswsV@yj!Ay|)()g;Bl!+K7VppADrmD0u(bP`ZkOcdCHI{_lOltlLJW=o# zE>voOf{})yQWR?5zzcj+DH^qE;ANt*sI3Fb$QKDGqlyNW6D2W`b{=sKm&&QwT-j#Q zH57~^YbJd}!DzH*QuVK(ouwR%cWWm3pkRbsGieYNn`7HtI)yP9;nqTWY^p%|Lh2s_ zrJN986@*sOFsfv(bRZ~+s)U1i^R1-kD3~|jO8Sg~dGoC#o4!y=GIw)esdFpIjf%~c zZ6no1!MMY=QVSG}No*_iLctiiw$j&TJ~9(annOkAK@TjD+Dku~u^cf%Dl>IQ>L^_^ zbzkZvJv8-5>MXrC^<3&Axy7=5rg?XhBc3>retA|)Z3J^Hdq>H%2OLEjiiEc5SN^X zNi(QmR@hDF5z=f^51dC!KeBup+*`kqa;cKFj)QWr6t^QWJYDyNqmF}2w)+R`gOnGXPq}No?>c5?*NKS)bzd)-$IDaR3 znvz^*N@1pKU6Q0}RP5O%RZ61D*47Pjb4itEp$Z4pCtAovMg}x-Nt0HaYUYwIeKgh4 zWwu17o{`$KNy;x>=17A~#kkCq#+&NzGGCf$YKY4MX^yE8E(@g5+XD0X0prtM=r9o8C>KvD~ z(sU|Fnd_1xt-_R6gLk@Ylx~!Veo!eGH%?|5!Xs7 zY6Po2d2pHQBPqtzFRqWJBvaR1pGrGXiwECx{aY$B^~m*wRATC->nlka$;!+f{L%HT zWNS)vdndV>vUdANibNF*uIcu#6m81G?UOXfRDCy2-blszG(`C=6}zTI`Liim5M^x? z)DAK7Ge@pw%2QKhH!8Smba2z;dZxZ~Gvwx``np-m-Kk3T7DGZD?Bxtp1W`5l5DI#T ztIH=*&_i5ZzJr2ZUn2wl!?q8eaBImfD0srHC5NJ*H{M-tiGtpEcR3aX zJ^UW>5ES(Ad&r5X_mQLBJmnQA=(qQj*P)=_-c#O-f`0Vc@<9~zqt}*8P|zP1 z{o!@wcPQu&_mbVmvTcC=a4*>x1^waPa!(ZWhkMI|P|zP&XXD z(C1xGE<-_Id42gQ3i`_H%O6p#Nq=|)xz0DNEzlp{Kn_5`Sb&Cd8x)KMXejqUK~Iy9 zJOl+jO+NBy6pRySBu_%YIDtlT5eoXzedSvyp7f*p%8#j1xL!lZ?+*DR6}#g6u9@0ZK{d+#}|=1WTXXp+)d_LWkZo>X$nle) z6!Jtpq`<9}yl4v3uS5QDi;!KWvKnp;F=};{8=9(CtD78b%B@yUxxK0SwR+3lsZNNM zL#oyKN}e?XN=f1V86rBw%Ii_KL;Y*T%DbqtINPD2wff1G7`qYHzE*$P={v}m%}s9^ zTWf&a8Rb1Rw$?y-GAdx`m|BD6t*8S3#9D*pB2$^QhRVlGZKxG5pD|TfYq)$7wcMq& z*4Oe)Qx|KEkgdLl+OxO<|J$`j$^lf_WNt)ktoXo5TzHQ-)B+(h{cT3;qN=FjB* zljN^yDfjivp-Dk+Ds9y15?%&BJRBUu@ zf_#Z8g&Q2-$~{5$PlYl|HJFDoQ*Mrec_=gGPE2I)P9W-CB{K75rd*K@`O-P>p*@NI zr6Oxc#ShhH%5`V4b|%J0xF^c}P>bSKrzCki)d{hSe|Ps}IXDASo)A~ZlU@s1o6QtQ zRvt)`8=ftUocxPL+y?qiDEE2t zE~+fz&GJ06n7J=^Y6NaU`uaoUi zWy9vXua|>S*27h&4e}SLe#7&$jdCZ{=HWTwCbSKak1BO9lAB@5iczE756JDQ?(52E zKcQIefhp}qm+{4NG^+P#FA|%A`4)`6;9e|GL!BV8L-K1(`HJK_B)>y783X!&8c+2J z^PL>?oBJVIUd)d4$1xS|M`SA|z2Vq0{+MiwvEgGcxF3`4QR~J=@W{`B*>E_bD3a|dq7!%#4H;HI2F#rEz^c|H}}yEordn0?B+U@aH9z(^>p7(M- zRXW$mZ60UPO?h4woAS&qPJ zm0eVK_?FY0J#Ca?QyxS$*R$GJPHW(4t9YRPn8pjXN*z>#>7cr()am{tr7!CG^kAaK zsCqM=xZ5g0sA)6y+1e^0s9$F^^R!c1m}=)~ue3u|`>r#QNY8>yuH*d)1FIdKc?>>RAF^q^wbN_8dPR5#D+$~03aR0k#5RHf{wtfpeuijz`|f_qO5rGyI3x;~yY zl=d57zhskH-vc~rDmkcQt%i9zE4xgM@pMsMQL(emO$pry`Pez{u1r9|Iq#wDq=Iw4 zuX}B!2(`Rro>oUGpM>&$GwMI%;R3Uk0@KwHI(qXMDel!Pg zsbJ4XS~XVYQNc6xd@Vp(O~qD~4^lRwpszJZ*^Yv~)*z(-1%0hSN-+xhT7#4l6!f(Q zDdkkGuQf<<-9+~;UBx0u@uf=UwkNFAf|RAG!UWROq~xHEBuw#aqF8N)e97F|gjVjs zN_*5Lq7Wqm)yz54DpcvVg{8ca@U4AQg?vtxrDz*=A)oDDO_2Kg5IQXC65Z$MfJA| zSI(heUDRfZwhijTo+iZ=MSGf*04nThQo=AsdzzH4RLR_!x~ZODC~;INMDsjbDLXJF ztf$&W*@vQiM9L`??ITjIqG%tH@)QL<9PJcoJ8K!NwA@~CGL<8CP<&0@ks_3~rtV7} zl^9cxq)y5=rk+ckl~hx&r7p@!Q{{Z5vfI=@Qj~Ja)Mu%yQeo;c|D|HJqpD?++)b%t zN|(DUVWw>49?F-d9Oa(ML{n~ZFJ+FY8*;R=+LVvnTiI*MOYWnbF?C1&O1VkJ?rt&4 zJ*ss23>Kq2M(wB(Vilu&L{0IGBnr=`XBIh^=6Li~`cj<`;FnvhG6n^|-1;eJQSckD zzw!vRn*9D7pjdW7DJKMYN*JhgLBa31AxaDio)U&CSt$7ZH%uu&!CcZ|$^#VKKZh&N zsMsBPxblJu?hLXpT&c0Es@07=zE-?V1$m5ACQ-5b=V)aU6}#JvRm!R0p1jI)ta5cX zlmdV8(rmv`UQw|b)88l`F$Q;a8I773`D^_d6F_31^47B%2dn;_xY(xDhlrN)09P2>@U|0Wjj?i zSqZM#bB6NKRHTqOH!GV_wUS;E?P8*5a-MRP3f@Ww*3MHJ?1OzqR=G`TS$m5TUqtsH=aQORdz-Qm z<(Zmad%L0?U@@Q61GV#&cvM*Gx!Svwd8qcOw`%WIDp66X4{PsJ{zb(T6)6q}p_F89 zYU<0{2b7XxS|)ATLFEss60U{+$Jz&#zy1>|R$egC6>y7{f2fi*SOK?K5f9N)w81^a zI)@YsRkF4!)rQCcV~Y}9>KsI9*lu;!UJ*-`#3^LvcPuYtV|) zT)b{7wNY>vzNz@5O4C53YL0vzp5&`XQZkkD*VBBxZkhU+7VK4FN=t9+b&rZ{tz0d= zv)7+Wb6RGW=9}Kr>%P(!YnYQ>#@|;uqjskcA+a8)U(!bq#iE{&ln<04sOq!IiAJNs zXO;1l%0yIO601}aP}525p^}PPL1GV;`Aqbv{H0`@D(C-Fj!>m=`)7^wdZb*XD&=7t z9x02;V4s!n$7fCUdaT5pVSE1CtQ4;&%4(_-{`IUmUQd<0auzc(vb>%tM}G!oat$(8 zdp%bM{la2BGd6j>P#n%PjUsxfw5KZJ(=v8?y;9Djc4i#$dZQfp6;hV)S2Fx-y;F`; zk&#XrXT9Dl=TZFZ-j;uq?H5^@4zqvr`k>Uj#MEf^9j||tSC^SO%qEi-)qpFk%mK5# zyd`xIYU*rXZ&^)1&7B?Mt*FaU8)mm83#J#K_Ra3-t*JGCW2O8$ySulp2BRL#?(Ai# zzE>fZ#l4x`*W02-p^Q0wy{*(7lrxdFYIhA%W^%rB26@}4%dfM1E#^%2uCChMU^R4` zli=;3enbtLGtb*e^}fksGv+MyuAv^KO6F$IS?BGn=G=xD`C8YUJ>DLwcLmdhIfuPH z)l#aH{DV0&?7Y;|RAl8AB5!pXJ<^$6er4ORx@rpQXQFy)*;yzhlY3kF*Ud<*jC||OSN(2tH6v zqRQli`JL+qs=;@m%u>#Ie$To=YBUwAJy`8T#r8z7I?;@gF~DjH=7ZWp)jcSvJybnI z1+~Z4ZK}Sag8SLvx?!sGJ*Y25Yc`+E0#$3HI?N}tKvf^AbnQUbQFXsigQ$|VlCI;3 znq#c{d@rG;+74qw=U2)t)hLWjA+c6!G{%xitd-gyV{pf8tq#K&Jh!%1zrol%(v~*r z6x4FkmNx45sGtS)g|_M}%-4Cr8l|ne2xEg5l=1D<E6OQbvvtMx0`<-ssw)@Dvd~tmGU3c7S`=*3jRLy_<#9& znz8F?&y8qPAJcxU`;{rk7x(}2^*3YJ)9kAaH1#npzwQuIknijNmv4j_yPkHi?kH0q z(@xhNZAweORQDToGTqvAt#jtRy5rQDs3Dn8iPBNuW!4wQs|%=-wam;l%6N4d#x|4K zx9VDq9U-xA)jX;c?YGQsmI>-E)Pv04MEg;2G$*RZFdrPviRu}Q!4aFJK1ab3o1|)g z{qKlPQsW<09kKUyC#$beE{nN(Q`G3kG^UNs>Smdu#-V=5>P<9^DqVvS*HhK8C>U`) zRb7Z$mQ`PvrY=Km$y%dKQ*%%=2N=S1H4imwKy{+ssDoL&FhkvsI+rCA9Y@{Ca<2EC zdIt3}%Y*153RbvJP;a2*C2N!f^%V+MOrEKJM8S&5GgY$4C^;w7HK!$8j6~HM<+CK8 z$O+YQNg4mW>W=ENq@1West<`Jsf|%XNi0bXLyae~WVJPFCW$4hol$d0><6_6Y8{FF zpvIz#mUsy%>KN4NC6#iDnm|SRnMo{FEy5U#gHKg&pK!%FGDq!<8WojD)D!h$$>@4>)mW6WbP~}}l*`i5_2#LgQGO&gPo0En zy)?1jd^G{pYiR~i8Wmf6c!4?}W3Za?0(B`0R#RS}u0g?S$_v#^C|FH-p}G?VD<&^e ze?q~E$&1vZC|GGZQ!PWmO3Rt*1*#OTfmfMjvHF_D=#yiX`md=qN|x&O4E8+ycDi0~ ziRw+2&V{AkskchGvr63bElMC~Q99Q7#*zH72heS?DUnygblqr%<89M`Mr-|UQRI8&&< zUbREL@Zg0FYE9H95Ax+OwKfXgxNKA#qTr3oMl}cpZ(MTKW+-^$lB>2u!5f!NY9tEY zxNK6RQSioPvl@qjH!hpiVJLXxlBbSE!5f!6bqeat%p7BjnuxkRbEv#UorQWuVq4XP zC_Qngyj5L}f;TSP)EpGNaoMJBLBSiB?don6ym8sC9zZ1|?y0jwJ&sCGEG9aOg0~#` z>O~a1<;YiWqO88}rtDPjp*+9$aonjsLBU&&UFvHTyye)XenP=pj@_#Af*m7x%duOv zMJ-CSslP|9fm)mBOyr5Wp4d&(yAsZzAsBvz~*L-~_fv3ds8 zk;D$EzoPn3T}O=}DG#Z4Q9rCG;}5HkP%BoH6TPBh&&fwrzn5@SvPs`k-TFt=7N-2_ zA63Vq9<&Ine_Ty4)vEppwTvpAj9DnNoK&xxx?iVMwR#0*vb$-S+KLM5n^wO}ji-Wj ze|#KItE*8;&2GvW^*WQ*cNOR!RSId@_w~=Hj<2E2WN!4T8FpvY7O0u4X4NlO-QKa- z!c~jv|Ey~7nO3bz@i?dM`oy$%RixD~YVc>K<3#7xa@0AZ3+hMIUqrvEz8oyhM%uZ0 zMg5EFV^sCkkye+~5}w68S8uL=SuGJjS)A|c!unTKJF!Z|^?y@4QL$ekSJjhL>6*)0 zSD&luqwTZ5vU^MSF^)U)Y^IlV5Qzg^=a$WtGiR{5ZpX+LX#M+|N4D-36W>KYc zeb%-lT5qbO&rNlQsa`&})M8WpeJa$)RLR`HwWECQsx@U+<_MyDY7A=X+Hc7$xH44o z+UY(I)B=O0T)Z~j=P&grYGM7wK9AKh)S9)ceV(dU=>puz+}^dDe4eY7R9WOZV!O!f zxp{Os?qu%5+9N)%)XmmVCObdhs0WzHYMJ$gH|lY!WUb*$vbvml7Gto&(_8f-#$bh~ zx9Uw6BWK+OG9yp3p=D~Y^4veF9ST;S`$u&~d3XHF=Yv`s71HrFkq>H7BH!qv8bp<> ztxZ&knq$l-hi~+++78v8DiTx1=BOkVjj{1LHjO^1aj1+O2ciU24vBqMQ&Ghv_F3JC zx|)+_&uQCHk8>6f6;qKf7L%uRUMs;Ex6ZW@ua%=}uB%OS85OXuK_fx?9o1=_KT#!B zineWC882#AZL9YD8b#C$J5UODah;bSY2j4x^_PbBk~Wpaw7wh0Hl{Z!NAS%lDe3Y@k)RG6}hg zZ)1&fXL8T=@(t6-66Um>A-S!{SHG6mX6lgp75VBHSBD9{pctvuMD@)b<{PD*@?x?0 z+$p|2wa2K*xifuxY31H5mXtf+H%7Zxmnk!Mt?vLWp+3{n4#mDBG=~OEa5awB+)!I{ zOMJ&_+fm1I%YDab%Nw$kzvN!^ouEbeFzpKa(|58~fLcd1O>=9+Vs~?&`F^LB_%Xf7 z{p_2hX#q?Qn{3Dz!D3JWn?C!_)*OOZ?2Ap#ehah)!Aw0i)$?1dH3(;#wkh0inRXMk za8n1rRhmN!7TdXLh+mFYOqI?Z+%(2-gSPz(7Mn0Q(Qk_u-J0p_rg?t(S^?_!O<80d zlxG_jd%9_zU!nHAEz`SAKlvTdYP4gr+I-gUkoK+#D3eQiT6g?W?E`AZ)8^xkX`fKn zpY|AkTvO;aWOC}W9^+4FxwI{rT=28H<4d$WROe^S$Dh<%(i-5rZfIYsMKf`?$Qb!k zn$(`v4rl8b%@Z|oV};)ttu?C6<_CUfwe6_r&Hwma&{{;Wd_y-|`~RjbK~33Q$Nz@r z+mXfQZf@dVp)EqK-Q3*&5A9ti7TdqMeyvJvQfH>`I(+H>mv){ii!0mQ+yAlFq6>@N z*gVkxnKlXabJ$4#7ur?SQKHvci%6EzWAH@(cbZ*SrbnC8{Xc0*Uowe#|MvmtU z*oC~v#;tX&FOzHRpvDn;CCX~^n8sanyI2Zx1$ zLCR7M=1}$0ol!7{Dq63Hf;m*tdN2y+N%hv-pkSUTxKT6*f>Gg@V~ugY>B=m~AykPeZ{BwZZyg6wFW?tmmL$4%HBS2MXp; z4bcyxU=Gz#y$l6&sD|oSP%wuoUcZZiIaKlb-zbjS>!V~1emEbULT8s*-sPn#VD9#G)XTq^Q}>)>Sa`9^x_up zfNA=9l-<@w0n_z&s4un#2h7mp2SR<>T=dp20>0C8P~UFt7%)@6iTYt{*MLO*)gVZj z$*tM?RX~#7W-!aQZ|iXKb->P4ncS(Z;{txrV^DX9Qgm(z%cpLe7LckZm`V;v(;EzB zrKsDy1Jdu$rK%=m1u5Cr+3x}1%AzwQE zTKXd0?`sh0_1bncV3FRMDxEvNtt=o*&p?%L`z>IJPLh#-rShF^_XC!ida>CS0vwrOM=nZSNkqTDKYj?JVV> zz8rl#3fi(xub@ii(zXu{T(4)0W+|a9xq2m4GMBS`OyDLxZVZb-%kuOxs$}lO_9=l| z^af+AV(x+4^d(fu-0kg2f!pl>(Spp$}H~P_Bnw&^#ZC=u6$dIz}>p{I2N+@+Dt6op=(bn&l~)P+Le>QC!x;31Yz+L#l$O3L@PM91OUdT^cKj50 zP~VGcw&PgfA^j>Uio}lUA5bww$94Dd(6Vf9_>MDyC3vHcmg;?|Sj$f7L#SA* zPw5#<+`1ii0#E6l-$E(r+!gm3c4zc5s$?#A$HTz0y4wVZC3E>ZBKV*6B~+Q*-W|^Z zf7Z`YK@Z%&ffw{gRM5k}AmEa2H4*Z$V|z)@K*6!StUF9%F*ur6^d%@be!uCJrrZOs z>MbU-lyHo$>5ELY2)wTUO2xM5hF(g=w)V#VI}TNX<6sH;-Q4pZ(;R|so6^$j1l`rI zvof_)JL(Jf^gmEncC1nE>5ou*6FGYQE0^ZF!I zD?j^ckMvcj(=7)DJ=OE6V64&CLCpID znBDuDSR0q9GP%jS&o!|zqGz&v@7vvIVr$%^%H(G6zTc#p;h6|AGBRiP%O+07q$HMd z^X?l>T#O>BOs;UZ5M0afO=hu&yRCygjmuP7${($p#xMQI7sQ-GhzesKOD4-9wBAOmtjqQ$w2zHI&lX0!8oMwCa|&A-7f>*#u(cu1XJx{i!nQ^=CLLxGwl^G6FpIFg(UdBad$ngsaC>7o zO4{oX+`(8*MOG9h`#QpKTL5LUV;f<_Qe|`5duIhl7$Zb7J7+Xxmhs-rjP{9nY z&q4DHZY887SI4BC?hA|tO!@-<3myxNUKoS3b)m5Y^@G3KWRdY4Q!ewr?y=Z#T}4YF zvvrOKEjBu#mbd&Ilx0k1BK3_AS!(P+!F7~voI^SKCxm1hA5n!PGD4OaOIEWoVJ7Pe zqYwq-%U2jznaFjN5VFEZ_>pbHb@%L$mBuer>^fR${Dw*^9ILG~lr@m@j-FRILR)P# zL7gYDAB`bQ{JX+UA#08KsJi=xYHN)`Oxbl`8J}a6qZ0OQ56LlJP~9hOsg!dJ*R`yM zjU=|tXv4(Ab+pbHjWM{6HW)vk;5yo1Y^1uc!|~f-^rNlLNMmp`?}ltN ze!-Mee|i;?YurR7|Kug)8t+i>U8r2cA&2e3ugMs!T%#Wo9m$nzj6lIiu3RIPDw~`C z6Bn9msoRMj2}5{tuzo zjGEh7zFxztHN9z!H&wUkEu)MoliRjGtmz%YY6qmu134|RKg*QS3Ol~mc> z%l*BZJ}`XqS(%mtgPZrC8%-rOeQsPr)jP1X z=?i-2tNLa03I$Kp5utBPeN0=`^ncRQbDO?1YVKmSH#xAQ>3icms^5XVO+OgiZWbHc zOm+Qa1fXUfC~o@Mn1)(#pwNZ4EJ7_O5-fSB+yf;|MayHVEbia|)m5=L?SV4cu~jYJ zRN3710~edBmJz6X2d+2OEE`a7NKCg}LVZ4Px2a*dhq6BSS5u3n=3ZJR=X|ix#m2Ie zDw}J3@NH9D%SBX&gP)t)TOOOz!m3&P3fT5_YSP!+!O{iQ?_ghVN6SRisDtAIoGclr zq=VJMYFM_TmJm5xN=&(hxmv~-vNCs(n7bvzlv|jmgY;oAn zG^{u_EXXn*HLZ9^Sg_?DYEJR!u%;I8gODmhOjG?0NC_u#T4VDCJO5SZ9mX zVOG1{p|Y?@%NVL`ZrZeKVP9IVpz0lZ7}njAafGD|JoGxOr{&dAR%YZOg?!gN;26_@ zL-ye@mYaA^yn6FV@~Wj5pOde2`^{sqpZ4%TZJ9!$(@4QjtA)sC)Q0i*$mOvi(qO_ykKNYX6}^mx-1b z)agS5!zWo1P&W^)51VY+h`N7hc=!}cKnW}5&7ra3(=0_O`@@AU-&yLNWU*R@e+W;o z_@n%YW?Di~Ee_8LPqcJJbtFo%j7If6JU{#g%S2TF{Os@)%Xg?Thx>Y`T2fHyL}`|} zsKrF-mMl~b(Jad>{s)>;|Lbaq)hbIA6W{Dw1c^nX zE|Kxxt1M-h62^P4vYe-aCzc#i<}<2f?iZ48wZ)PGWhQg~$KIRAM^S8jkbo1(6{4()2pV-FxeDGW zAQ45PP6QPcyevWSiuya-n8pZ?_w(N8d7t<5`Ta59@2OL#PMxZ*uCA``nK?_Eh&s;otgh=O)TroC7hyI)|o3Lg|VzNE5s6GS!Y&K ziep)4{!FPn_1mW@+IlnVv6|Y~o8^+i+Si*ElET{8o8HH3YF}^e;}q4t-aIHNtbM(i zyp%1m_Vs2erMUL>=0r;6sW!(_v}etSC6z*{%Uq6n;#o8O362b7dDhI76vpzb*?M_R zEYF&8oT6BsHRC0Pu{>*T7E6rfS#u|)IF@J4!<5QXSi8skr=(t>RExiH?KoOJX0D_# z7LS=PDU1bD&)3A_F_&f<#^-H07Nm3X~p{X`;oES@?8Tmp@EQMwarzn;}v$do!mO?XIEHRcsGnY~vOQE@z zQhbb_GgEhWyY=PEphw%?^^ns5hFoizPf2-v;uO`l$xN3N*0;$VDVA8@CUY#MxV}y1Cb7i&ip{fN~3uY0g)b1|}>%Cxp*19I| zMe{38sl?;GhrMWajjhSsY^HEZO@h45W_T{YFnEoM7OVH>uXo5T{^u*H0ZQrw0uW(B2q?%8Udl~n7mQnamR&Vrg) zwwhi^VJutCeUidhwwg=aHL+|pS8$4A*=iO@3S-%7R*EIYvei6ADUM~U8I*@!@>CJj zzRk?c=i2dTZZkJa3TxkH?vxbPzRkS6h-=5I(>Bxg5SPQN(>60iQds*o)6FURHqtip z5lV6G+suuW;w!>-bFZZEim=@b@~}^=Z@XE+DaX{W4~^PxR!Sb$x7|D;DXee18B@rS zVQaUW?J33eZ8x2i;`(;LSzJ@Y4s$D~=z6=u+$DKf!w&NeNns5;%(ui6YuI7FODV2l zhq?MC^ogky?IqL0DRtzV)=ghBzp&)(G{2F&?;vld`RkiC<#w3?Z&6BRpX_?yF0+B8 z@*(xAX?wrMa<>`6Db?fKy4USC^Cflvx34#Q-CXcRjb(}XFsD@M>Cr(YW{|HY?+r7Y zQ_4IuI_M4aM_vED4R4yiaY}uB=HZENn%nI)d2gA!Ii(`LubcIjdA37Mp4SYGqm&x> zedDQK^YW;gyizm7#d*j78I@gX+9WlJxIM{p0HT%Gfzui+J%%m_L;v*Y6hidW!L!JXU^x8+IZokS^LcQ zEP4CQ4<)Z0^7fmJXV#Q^&uq>qb^b!c?Dx#+mb`LvuH@CPj+k9;?xtriJVHJ&4{}N+ zR| zJ8XW(Db?uGp#_IcgYIk|Qe7ZbVa7>n1f)JPchY?hmpfvXa7xX)bc_3ld7kbVIPYWg zUz}2#FKui5u^B;k3=gUIA@zx=l%^8jLhMP{&w>L$*402jLyaJPjYd=1q(RhGKFM5` zz5Tnmj686ur%6WCCAJ#bP|s2>5P z9r`E4i@lUYcsF5x!h0+jNV2uwp`g)~HA2kQRc%YwkNATJUFx;^oJc-r{K3+H9Icjr zMaBpEfHd4oh`M_4cMZ#iT4vF_2(m#oHj7@nqSf49D{`OgCO_|4@UO)D|GLcq zYHtN0k5xSTboDW449ofGAOF}_e%VK*_;|6NHQb-?HLZXM5ES1Zfs!qq%ntyCz~ zt|>12*W+Yw^(gGhCN-oY$`RYTi0P?Yg>?VqiakG}0Cy`SbC1H9xgu zu*P$3*-5oCCXtM&tKK9JCwUaf_meyo&`@k?^&Ci%&m>Ehb4adTif4=mDfh8IMgM%o zxhug&S8K=;QCI6pM!jayYwB;5%a)vr8co&6em|^P2|K+0x?UtpZqW|%vxhV|Vs(YG zLH_;MN~=xnQr4cSoy&2)M?Nd4mfAM8HDL#^Ev&DiQl|lRRZV_^-^ScRwtpa0#te8sn3+4pNe8l-U9-||OvZkyWz7BFO%DQ5iui8A4S;ni9roIIa zuwo%UcwN&JBG2|LU#Y=f@~>~L*Ngvb@9}woYc@ECU?15~fq)vxP&>)i8hHk04a)vG z+fe0Jw>uL=8d)Nt-1fN$gfi?cuiYM@;*WyY1|6de@J?k z{|bHz_PRPwrL2CitgiUZ$m-`i(*H#EyehNej4yC3FMDn1F2(iM=>2EbBC@g8Zk0Kn|CvaZQY0MnYLcxQ>rwMiu2r*{ zGMknmzB^@Nr>#?hWfv_`lT~91lmrt+2{_EiL6?;|9(F>huGBx@@CCNjg4j)yF|#d znbii%+NiAG275+Ve0tEoEhUJcBI@T^!< zHxu$s6dwyljy#5PTM)Jd)Kx5?q2d8;$_Z#!yjy-Z$eKdb)c}%5k<5Cl%-*I_?rcCq zsZ$RT!8)X%C^QQ z>~YmU9mwVHy)w=@83z_wYpVPyG57_ zPhJ53Y)7j`&$YmQFPz18xg+57f<4s8{@VYzuVuSpf1@T6UEvzrP;Xh-a zct`J-YwqiHg?htsr?0Cz@6=cZQroQ>wzq272KBZ-Da&_`*5mlcveszfXj*DV*|@@| zHS$0Dxv~|tBgeIkzXwqEd&Vn^rVzO|tg@kQ{XHIk*^a+!bcM2^(n#~4@^kHTt>z5! zUs=%p-#weGeg3~m=3~l;cd!1@$gSohcrDrAC%l7!mbEp!WG)vCaWROPt@f0ivb)-4d@m{=3C$(6emN(;Q9Jf1$#Gxkl%BK?bpscQQzpnrt0C8ITd)>x01Rpyxg zsNw$c_Y&u_Pp&tUB1F{HB#X@Zft<^Cf7}~<4%WWs#aw@%a4meSd1b}D^hcRzRR7w8 z=WwnU(cc@~pR*}8&SlS6yVthXUUPK(b#X6YPx_DSA4h_}6%SI4jJ!&$9UHGU5wDDv zSB$lHQ2CyPTWT%4jOt=P%ihJAhg)Iw%(eSV;T**_*B&i?dmQI$sg~ynS$>6N-p$}% zt=(hX|9_=Lwfm>`*tU)nj=biG_{ZwCTg2xnqONvR{QLxsXC5oECHE4~GmLyRIhSR$ zv99^8vZlE0*1Kc&`9F_*jI6zC?W;fP{Ue-htUb?b5^g&p%=t72T4n24k2OH`BR^bIl)I{yY_;@|4ab8!8#c9#?5{Qk{<@x@TfIWw ztfP_F75rSOM*g$W_~)hk??_n7;u9_#jc5B6F@tfweH{TCBD`p>Wb%WUjHEa zHQZx7GqVjN*To)q{^!}A*IE_SZ!G^6teKIn+>59pKQ+1js8FM;)4%7k-mqx=N0}{u zvsi|_hvU2fAlty(-6Ug+{O>e!DW1Kpa&4QMvi``~o_pipJtAz+XV$lLP2}g@wP!Qd zV}yok3h~<%?xWgik2gSeP;1}2u}?nYyt=?>tve)!YE8YtHrxYzlv#sUBG~VOdTn$~ zw5uer4^V>u1L$dv~lX56tll=FUdiYP{ z=N4VPT?&p%fW%hQpL|bes5R6xsJE*^^3T`P%^+L*%}(zy2Pi&j|CJ5yT)p`o_Domm znFAmPE1xBP>?{9O!#b+jGmk^=$uwH4T(Fe=Gfj;*f2kS`UL$mh-#>D2B-o`-@Opan zT&p)6^EP>7_OF-1a|fP$L3{nj2z%S0(P&fQ|EP(i9?1SkaGcvL<5?$rgIZyO-8@{g z-3<0u`fO*>bOG6*^MXe{wink<+>@!6x~yk`HO|504Rd+@>8~C2c6wh+Q?>ozH$m(w zgUWL6;W0H-wng(W$c92oi2q~_THkiC>UrL%y+6t0gs%=L`;Ra7xqoKhv)*d65^BG4 z_Fx-sDM!13Y*^3Zll5E{bL}#p>;hR=nCstP;z&?qqnYYzky!0{_Qv<4aAnT-IM$dk zHorZ}{&R2XLu7;P^~e05vcb_9pgys*x^`WBt*Jett`-mXp$~lOG!o!DbQC%I z@sA&Fd+oYvw+r`7aD?Ms8$UtjvV0z~%%hZN>Dn6XfB!n+f3tj%jzT~=M$2;u-+{8s zt+UPsH<2Z;TkxLIzxt}Vo7Pnn*>EnuDHl%~es_+?YHef>t!amWb6JBi`1eI?dK=y{ zrROiaHzMyjKrQ~=64tN>M&3_gWdHpssu31s4eyxU4|+pQ2ehd?vax#L`|gLyW;x~7 zvgjg@mY^Y%wV>1*#E2*7pwe*l@ zjvVhRb#*tL1xe(M_kmv||J%rNH_2}R8tQF8n<^(g&pc>jsED>XQeaWDNfy+0CNJqn)vKA*PK$lkbT?v`;yG;yR>8k7K662YBUL1MB$!vAJ5=EA@X~wiS50a*cuS z*x1w^QVZrgqh$7_yRN4X-L$#@OI_89iC3L&)C;tP3){ zeMFk8$qmV-G1*wJN_frHmGzp7-#3A4E}*8OsZ=Y#E5Gk~C+RzpH+-8~Q+~t|+YsLQ zG*lPLMCHquA=dg1zY7nA%T*+I{xt9(d-l;x~gIPYpTgvM1G%~{rtJ?_ro?k3t8ow z^|^m_y`s7%2CmVH_{Oq-Tn%^&o>szcWdM9`P$r-Wd>!bLRFIYepPnjG>jRoTpzo`0 zgiizbpd6|7Rc%y1)fhgv!>1#BZiY{Sx<_?aL)1`hxXRQrz;3i^uEr~mHUT~p)h76O zv@G~cQrqF<(I&%ZirNhyk2V!P)07uJ9&I{&W`KSMa5m_&foDPaS-=lK*$057*W4UEz}mpA`7q0H0~_nF*gc zYAN_z3jUUYzon4(1k~{)=$-`Klc0MNbRLzf7eX%-f?NnKE`&ZSgxWT!!RmQ6T$QN% zR2lTaQ8iW_gIJD1EXTmMQcZx*b@0hDDnVZf`byA$4!=A5Imn-b{DqnfpXu{-D&|L!ECD2_4 z-DS{S2Hj=QT?XARp!)@Mzku!+(ES3sUqSaP=zay=ub}%Cbh>s#*R>mfKLuV4Tt^w8 zGeBp6&H$YOI-Ax2J~zOpuVw?C4Rm&GxMm004srnK13(S{xxV@*{4QEc^(p*LTpZxC zu-0l$+l%Hf73FNIPg5BQOT+W23cV6!y5 zlx#}DW^_;~_(Y9o>^qQq^Mrj`DcP5T{YiT%)lv$zltb?7uJ1J74?ZUVCc^K{?^k*7 zJM(+gYZDJO-lNWt+$?LKwnvR7+(39f>to1`ndAc;HVJcAPD1+wlTttqoBR#PgC?H= z+%y?;)fB`&fVm3)K_FM*KL_M0{8xZ{YGXddpHFSfr#9wO%=y&DQ}A2I^`j7*09NF* z0Bkr%(@&`}gm27g3z{3}#sQ9*d#3RzwRP^Uuv04NfliT38K_hl-n z{rXmAszt)njicfJ1||hXYjfI;16nhZD)OHZQN?7@!$GEKSUy^c1N3HThhrKTSia*LWdkC~W<&FW`mml8Q`KWDD zrv>3vwx<)jbgr`b61#Uso3CwEwgE|fNWN&ZX)i_;H%5KAHck8S!$F;=X@Q3ab)KVL zPuTSEy<~aJe$IF?A{y-59^MD%AO1T3AshbdPJ6BM;aA9JcRQ5d>fBySKKw!FpCJBn zupD_f4eGBpjCwjUyovj}b}#uo9`^IZ_u& zrD$_Ne}g@S;yh$)xo3FCIogiH!{V1~uN}Teud=;!_^J2|?bP8l@vXroMXR#4Oe_W& z&#Bhh&xd!!SJ`rsK97$h596Wi$@rG`9fza4j8~I7JrrISP}AcncN*l5>~hE!Ua=A| z{>`;r@<89mNG8vD8umZ-LyC6Dwlwx|mt<;7GDVwAtw^SN^Ry2lXB*3*)G>RN?ahR< zU8ZU6D=vc1rLkJq_F9*U7Jw-gZMzaJT0u==&tRd z2kg+pX%+Wrd0MANPZ@by_eO2>Jgr}&RUl_p%md4@js9k&QoX4#s!w-KrD)ShlTMm+ z(m3pMDnh$ufo54)HjR^9ia(bubE&Tm*^=5n)D2^P0J4(D+x;o%Lpq7mk_QXEFdf* z+)Q|a@H8Qg5WC(H*Tn;(MRP8rC{?Rb=TM?8Cu{Ia9-Y^AhZ&~hk;TR#TlH37;vQ(xSBY_8U)(rO$5|*& z$GOD;=kMI`UiPFT4|a?v|A%a;M`Du>+3q=_>B&0&8`mM*kRu78894S>qCn;xmXX;Eh#D(RyZ-rbp`^A6cK|uzz=CV^S(b>#(0avKKTz z9yy+Lj@p~7<9~mpQEoioE3rS3UJHO3FS$L<-aBcmrc=!66mvRQ!WEx1nWV`iOjxo51=WY#jmd{JoON-o*qVIEmiO^1pt0|Ho$zfy^pK^~Ij-Zipk=`7 zkI#c;517r`2gHB!b8;{A+&v)x+n5mWM4L8xFYs*Fb9MZW9-OP~dcKZV&qx*AHbu+T zab+?!1Pbgbk7UO|FjK_z!a?ryq)g4nJhPxhs6OmzvfI?9MBlBC7q8u zDHq4vzLXNOFC$GE*_T7Rnm2XWe?I(6N(IO%S_PdEhito#)$f7V)80LbNK-_)z3kp& z4|c31O-H!0RQ5;!Jk_IwG$rBzqdGygoS<4NNnc5|pC8{x$@C=#R0fBs3vch32g@UYKVbnoXx;vXEX4O zjv##`=_5!VLHZbjR>%g9mTHP8j^sE4`#+v?lS#9~_;k^bUa52ioThdBY*_DU8eT)O zCr9;8CI6{L!e=RWq#C_GD{h<$WheJeqq2vz0iP`Z8GSk+&L^SlxNb zdPmae%~TkFI>nY{ludUwao9sX-&>cr1t@%KK}-AQl~S0@ak;W3kkERjX3h_2knP= zP#^#K6VCBkM#ApC3HFSHxB4Ek-Tir4-&3}Xgoo-+1O0n_=Kvn+yBzS7zWK(n)n5ZX z*Y<4RHK4iFwq$wdy32DkmQ%0IH(v*{?oHXU6sUS@SX(~ulNt#O1RFdWdX-<&l z1Zhr_<}_(elct(9)ugE=&1KSDCe3Bi*le`gv|+n!uu>{+97389(u9yEf;17Ni6BiR zX(CAzNtzha#E>S2G_3(sw4aPy-H#2Z3Rw5~ssTS4gW5heAkL=MgX@bepkB%yfG`f@ zY{4MMgZ+Re$)rI!MN75eS(9eNvnJh!^I@`$?&C|?(fQ&QGme1GT69;}e4O~Hf9QNj(J_8;08`_?{!(kukbb%hv zqXP0-K(!Q6+0BF{G_RJ>^?E18Q$l_=)0Jp(K;;)DX^R8C1T3@Rd|qb5nLnN6bQ|8a zl}jXfz6)s%`x0MO?+VeZ^feh&333Xo-pi&xHs}QDPZQ38JBarN&7nDAj@G*BQ;@%j zKRIX`$QJ>>i8lsk=#Qi|zcE8!nFcEaeM4I8;A$$Hp}&+iYVc)|OViwgwZQwU9s+y3 zMrY`=qU?YN)1CxPPL-yQ*Z=M;96Vm1G-wlG?x1aePYl`x=o$0|V9B5|zyrhI2mEHx z$AHG*F9^Q|tULI7!i#{>gC80^O}}^WFW@<~>~Os%uQOagZbgv-g#a`LlWM?cHS&vG68tRX*Z$j=(` zvqnchg?h-BVM9W|L-VGK^~A=jZz_bV$w_;$UOeQd8zW#Xx1n)_9rqLVz+7tAcMv87 zqP!er=a4mkJ%*G5M%#J?e%H0%kV7C39?~nYaLb4x`#~Nvq*%9iU42urzGuj9H}0T* z-a-AmhvYpZm+DQv)bvvQR>BTn!ksDQ?x)=S5dRGDiAS?nU_96y(i;w1IV6%IKSY*? z$np?b4uD8@LL^y(UkAi~9tJU|Xh$KQw};qZJz3n?2G;_(X2E*+bk`U=o?l1x2fj?v zT7za;SR85K?(FlGU5@IDzKpiT*zsIAsz3SV-0*m+7guPmf#U<;Oc>rVnT|rToz773 z|66RT9nb4z@Rr#<4ZO|mo(}84rQL0$w^84w+wsgzBhL=|``z*EYwp=L^r&9`CH!{; zM4O_G7p(g7_|T4lgJ7j}R6hqXWRmAB@|;b6vdMpz#Hk(E^rQNX$D?iI11ELLZGc!t z_zOT-z3iLcc(7wHd)4s=JK`GVuHoag@49vc#Cy;2+PUN1!P1vF z05B(M$nYv1?{-h=xVktca^;5~fn52aT|Wg6Oz|%G#fayJAF>6XSQ(3YZ@cAm?iXq| zp3w9(x@O@W(1-@O?s_PEJmECLIfMy>xKr^^_%MQLhvT|5+Lmv}|9D$M$1aWb*;eq;qbj5;`)8jt98qGA{_1%55_=ue;Qwrt*l!>i|NW=Lj{oXV0Wo-t3aX`o z{8v&8l@voI7tV(&H?@~!eQU{)p5AH`4}(@uD=7CH~=F@)-~{sqps1dO^=aytz0-#1AU678BM-! zs$T}5>qcINakvfEHg|r#U(v>;_YJqic0Inh;0`LkO8GtiPWB|?pF%(AY(_9?>h! zY6b08u7Eh-j!mYrsR20mrjdtq@{ma$vI20%$bwpycFzvL*(N&xud2CZnMwx&{Xfq2B@1M%4HFb;g%aLi%@?|&B?pM84^;H<|xjVT4o zXj`Fi*RAl+#uRfZ#hjtF_%3to4x__&``|tcW4=t7N|7f+sT8nBeR3dPxp1GyJ2pcr z{jO&~FQXc8hoPO`r=8QnPT!(uXiZPURnm6m8U6k=Y0O+Bk^kOwhQ~biQN;4qEbQOcuqN9f%_^JCN3yVEUSmtFyqX1;~h5KpK;jmzt{6&J@9ty67ru9_)2Vjx(mzDrkrV`m%!+X z>s~@PS2Ir%IJ z#IvcK`n-f{tN_n2Lz3qT(v$?^YPOQ(6VwlOX!@v;8!)IaGPKCR6avD{>OvZADJPJFLh_@#H5y2=6%JgJ^sP z;eAJZ5Z-Z=!cq8TN~xCBEVfB9MUqOGMp!_Rr;~?FiZF{J%nrgaP(bHbK_EVL%7&QX zz9R_7XMPawy(}RQINQ4h<_BS~o-*(sgHORVv8ld-ycLkQBJx&59yU{5JITI;Fdr;4 zyO)9G-0tOMSx%N^L3l>nbb96myIYZydKn}CIjwF1oqYu~Zj0#oMJ^qeTsl%Vo%Z~V z+5g0AO{+FRGwK?ZZ``N#qI%aDPyI70s1)|DTh15&HQqL37}V8N9~OjX@c^o^9Ij$- z$EL%au&r@LP~eN3+Eo&sAUqv}n^+l?2Wx=! z?W^JJXx=p4ar58jH%oW4+V{|`Oz3TRekwBRGadLpO!0IqG9CCYOj(XV?{9%wj^qpT zn`M)IHfgdQ_&-d^WSK3w_+L!9j{fBbXYGN}IHXrT+2@lc-+}+eluGtX93#pv&MF0) zaX~A{W(8?hIPhPY3M98%n@K@Mlv_laA_x92QyO{LEVXoN(`EKfve`+RoeunerV`SW z(Z8u@XsfH|&vw}7Z9ks0!+5TGpSA)3&tehJke|5j)sAl4_QzfZ z4a$AD9fsTy+jeQyjyZsp3jN!H5i8+o?{BfTV8js8I21nhSOYr%yE@>W+mIZ5Ixs4y zm+?dO{ebEsUMs^c&diAj#xoIj`|bK3?VENbISxnK#eLdxt!(<TFJ###x#iY9+2O; z=mHF{7z20!l%`RMJ!XO1k1#!utci z#h##Ejn;5K`2_Xt3F_NyxT<0<_R{WLU97 z*%WOF_*oXVf-DQ@I2O=xETURAlg-XxyuOzZmVu@>{6{(-aonG&A5=m1rN;9=?9(c# z)Cux=ntWCV?}F#l)xnc)NW9}RdAm$yZ6|EzK2=FI@$5?@4|rF#YF-*y;#0OA^YCd!-y6njN$uaA*An)S@6*n~p7T-zp0d66 z{+&4Y?hD2lbzkr~?Zj*Qf}>l|7y zrJH!xIP7zOjGv!L(PmM!*(B$ZoKNxOQ-rp_JNFEL=YtP|xAyAeBWeL+2w{D~<_p?8 z@JU$#dB!#B#05B0EnI->{{c-(jnh!J2yzEBDWcveGVuu^*!aM_dxSu6`rD*Vf-crfF(!_sx>t+A`67F^UaB01p_9)!F?D!AS zz3lkU&_5Z!UV?tp-`(=EJ43@&eTL@v39&w5E5aT>;aWZIr#)bkL7FVW9KuC}D+r$h zw8OW5Zv+fc^#H?F1HcG)Ys{|dsm6ejDhe=4-K+(v9Cb<$Qn~7TK)1R8n6EAYKB9gB zT%vR%NG(%=fGbo8;A&MDut41i=ur&;i&PZgCe;jZv$_@VH2FMBKC8*+CGvThd@2on z+BEbTq@m9ct*!yzJJjlFHh4#^0bsfo3Fy)q17>PbfaA0dHk-=QZU>yI-3gejbp*`O zIs@ivT>#x$H^6)?0q_wm32=$l9dMb}18{}b3vjj88?Zp@1L)EE*@9Fh>>>pzpN2hf zLc<<7sbLSC*02Z8Qnb|+?Inu#GDI5$uZZ4ggsOV_pny;nspkX6=>Gt0q3eO6szmzXGyLm`4U-PCJ+4$j3Ldy7={{HSGs|oT?V#2)4(G&&cGv; zW#EyTYGB*54LtfQsO)MgTR>$!RCW{TH3iC+mQ)+o(%*))3?)rEX8ME3j5;gf|NG^BQFcU$oB!Nv3=A|3H7@X;`f#KI2Laj~SSrYYr9vE7D%^pkA{7;gNM1p50m&Yc zi%jgj{vmsB2~}w!<$yy&ssPhNP6N6^%od?4Gb9plTu3*-tdMblQ$yweW`{fim=m%J zFgIj3pgZI!V1CHAfRBXy47emDxMiqX7SafCMMyiq)gc`L3qtM&^n?roEDFg2+!Qhg zaC68bfZIdX0`3fX32=AFTYx1Y2LZhyUjUYcoB-Sx@-tw0NWiT@syYN)dMN~3dN~C9 zO4Y$WvDLx;52}N`8dB#NSccc}0Y=pM3NW`0mU7p@Qu%eTAByU%y$vF%^BmyjIxhll zud@qqXPv!(yX$-iSW@TQZ7{#p+1d`~w>mEa_6$WosiEkne<;?T7K+DZXeh=om2$Hw zH-~a_Dc4Q8`Js5!9tp*xwj>mf+OklLc||CWnbn~d^%oK&cz_(^C2U}b0u zpf9vH;EB-wfG0x-0iF&W4tO>c`>i^36v&rCGXXD$jt7L-Lji4JGXR6aasWfZ<^e{A zVQ)l*VQ<8QVQ;hu!`?_HeNWP-lDOL!DuyYQwR;hYV}*2RZo z>zv`(y5w+dUC(fgBsCl(=^q|wL@A|ShuOL<@C+k4ANeU`5%F4MDe*+3v>WOlGZs*K zp)r}bmC^S>)ZZ)lFN&Xr#s_ZHH@&_6X z^PP~7apeKOY|QUeNPMtUp2m8gFnn2q?4pEQ0>5l5>FShph9Q20o7$BcZMH~GB2G*m zExdvF@#LlfO7#x8zIzo69IRh+Fc%7M0LJ`MN$-_(m87*`wvQH05Y7-DZ7P*i_j`RI z@MtqJd4r_)Qu^n9$BA#~KRyK8F{RgH;sd>kiQC=1pLprrr-;wo?GEMoJi>*-USXf` z@i44!$#4V4%V_iQfmIC8( zsS-X8jQs@5b}FXN)aI~;fxKOxMxJp>Noy$9bUp5+#i=O10`-D|zwvQ5a3cG}T!YZEaT*7W)pRnp8euSgDaymgcL)h6({0J8c zdxc@D7}?5g(i6OqBS9 zeZne<^)}$^VZKWic8T6C>=E_~`-D|8m#-3rukuklqlBHpF5x_3Uk|oZJ;h$wDeMw< z3wwmU!m5{)6VAAs(|N*$!llAh!dh>(ixy50&JfNME)*^mt`gQ#rMz&0aE5T6aG`Li zaFsB8k(2r-S~x*CLpV=Z>nnD`3Bnn|dBTOlrNULhT0bc-oF}Xe5WR4MaE5T6aG`Li zaFwujkCYcy1C?3}>;4R2yk6!B=L6$-DwK4oaFwu@#`aah+92^OoFJUx=ON->xKOxM zxJuYNl;?S$a1}7dr43__0>*C0!*9U$EulDV!ke0>*kW zB<+@To}>$fONFb1)xBI!1IDkP`FgsmC5l&-_PX}gfsj+ zp7nXcg~Fx6Rl@K^Z63E1B@W>P;SAwC;X+~GB(_(RnO(wee|ie*-NGJWuW;#9&aV=N zFM;#;7ETa`uSWCu6!v6u+AAD2i_=bFm#|ydBkUFS39H%SSJ)|>m&5u(;f!2K3zrJ# zxmoWKE)@0(mkRrYtAtga)GO=~b_;uiy}~|W^`Mj!b_%=RbcNIb$$;i9!%KDmI|xlZB{_O9o7+_Qo8USXdwJn-P- z{XDZ%*!3chcaN}pGpBvR?yYR^@$)wEFYFUm+r_`IQ`o&j$_x8mV*l!8W~Z=gC#Q?{ zaQiY}V~#12cE81(|2A{cUgoI3^Zgw7}(s zox(0*x3EXpE9?`7A7$Y3!cJkAuv^$8>=pJ2!w)!cd10rpOV};!5%voEgyF{?xV*4a z*d^@tr+;KSx3EXpE9?`7ABA9l!cJkAuv^$8>=pJ2tDm^MN7yUu6ITD?eCN;1-pkBB zVfe8Lu3y+G>=Jehd;I*HQUjyrjq&IjmGcVwgy9D$*q^Xd*d4%nkFZzRC#(XcoUl{a zCF~aV2z!Nn!tk(`>lJniyM*1s9$~MrPgpsmys*#YG(7%gzrs#om#|ydBkUFS39C9> z-Ye`Ac80RvCF~aV2z!Nn!YWMS5OxcDguTK(VHGa+!cJkAuv^$8>=pL;^>rm~VV|(N zPW%cxgpAd10rpOV};! z5%voEgyA&{u3y+G>=JehdxX8hK4H~R$_qP%UBYf*kFZzRCk!umaQ(tgVVAI5*dy!} z_6e&-QeN08>=JehdxX8hK4EyZgzFb}3cG|o!d_vYuxi5P+&43Ogq_Ve?GknidxU+$ zs=3rF>=bqhyM?{NK0n{W=Rb)*skmjjqcmZIy2k4GG_{V zk~CUZd4+w#Dw*|B!cKp>2m5sjyM*1s9$~Mr>M89Ib_%i7pVT9)?&q`{nATguUSXdwyaGi17bWZzb_u)v z`tfY%74`|M2~u9zDeMw<3wwmU!aiX&QOXNDg_X%8*b_@H2)fDk3>=O0}dxhb3DvB#g*d^>1_6qxiozvLf zCF~LQ3ajbjPuMN&5%vkI84{ncOV}&y6OPIjJ7Kr5N7yx!^WDN;VV`i+EGaMS5_SuF zg?++Nv&CN6CF~aV3j2hka>QOZYL29Z-NGJWpRk(Cb}nJJuvge89QAd4zOYN!E9?`FnlE<38oWoS)LHnIz5w7KfFpr_295)c)HL{=KBXFI znVtXM`Mu7EJ74a6YkbG}r1)|1ug3ov-?mHNE|a=!=u+HeTNiJavM&GVaE5P$kM2)(-`o8{_n*4ol+r4tQ%Xw8#+27nDpRiS(WFO@9s_%<@3Fnd4?R@R zz@A|}TlBoU=lwk&>AAY+`kt@$4DHpdS8}hBy+-#M-z&BEnBI$euj#$6_om)2_kOeY z{@w?ASM)yC`?uaPskf%KOHD`}l{!9kaq8OCovH7o`cnUu8q?>FK0W&k?~~PMexHZ? z6!v+&&qsYO_A&cL_if$x_P*WwruH4$cXZ#`edqPv()YK%clL|#m)Ng&zk&UR_8Zgh zK)=du-{ayXD`#;jZp#S#%W&Jra8UD`jis7FP|9bcj!}WVZ?v1#&(Y~Kk!?nH9NA}N`pEes9~-%4>0@!V=}Tcwq$&p(eJ*Y_btEg!hMmW-J{T7)*myG`yl`QFK6CQq6?WAfa|8zz@cE}!g}5%2kp?wgl0Z^^v%^In)&GVg`4RKi%>Qiu+4&t7 zEMKrcX8nTV1#d05w4kfIyF1P8c5imS<<5Xv<6(GV2Yy8ne%sQny!g*isa)ee3qv_1URV+R!lGuEx@4%J3=18o9myQ^5$6STeHH$(4+ zoZjkA)mPmGzZ=?7^;ezM02L3vrr8A^?Q~UxpwwWM2)`woq=v%7zF|;$0zBlKs(Pqt z;AMvDqaJ|LxlsC1DDgOySPGU;sC4+n%#rXroul9#YL|LiWvG|n_c-5#-{O2njZ^#K z*GLb6r=x13`c!4X?{ZFp-{73AK2uYa54;}-@87^C^J%D|T4lp_#7y|D%2`U&X2V<5 zIVw<_qk^@$a2x!9x=zbg^|bk_p|${K9+f>(mC#qn_6a)n;v@ z+Ny0*JGHIqb#0q^TidBV*IrSE{;IO+yH%k6nsVr`s~dE$x>0{ywb$QQaryyuyM7Sf zgFd7>=|@x-{iy1uA5#f>rApL4SH1Kv)ZMyI4c5O@!}YIJx_(ZL(9f$;`URDtSF6$b zMKwnMQQfa!Qsec@YNGy&nxy}#robUM3m9ss|Sp;Vt6;6kiAH}HVm zv%%j02NF(bPz*Bsf(Kwf{bj&M^*w;u4d71*)S?FP_m*mDgL1&t4L$^1S@#Iw`UaJN zMPyUlzz6cwM(Fc#Layu8n|2yX?P|OS@Quc3&l*Pd#`4N0nEPxK^zcoSx;CZKqFMo_ z6SB<~l2ISVr{|Wi@S#Ws^tmRq42U}5Z5I#n@sulJ_ajT#prAk|&<@d(ao&)fsR*p_lM|!efNT?@EB&^LJrO>veh* z;^H6J7^Q z?~Z4L5%LqrfhkzawiN8oH&Sp^bO;=E9n{`q4B$UQa8$e-k{zK`kHEQrpM|&qivk`3 z+~0Qz;H-d^h+#N#7TeZ>T+z1>@FsmD;CFqu0AB9cLfhnP1h#Vz{lF>qb=hjxIn+;7}torb3TuHjbSGjteexF^}>o}pQP z&@3Oi05t5AE%WL=`MVA4`6#f5kB0sYa`{NHz14<$_>p_D$2Q!Hef}z;_1w44tJZUb z&mcZ`_#EL`_q&le#&+59EPJapdbZBMJSWc%{h+>5&0T28^GU1=uX&ow^pxOP4_`JA<$-PV{nT0VdIjNacjt&#s+=5zLH=P93|e75p=YQ1vt zb(zoErBm?C;+e`io2{GjYh$H+Q?QM)opl;Poy%7k&Pj zCC1NJOzYgjN9U(poZ+ptuWnE?=X2}0>}&FE((;Pi!vSqlpR^A~OgTtnzs^fAbf)s1TEAGaSa!ZE*P`Uf#e z{o^r=v+A)5kbfq*(Gt{jBwW8FyqQwZFTrD7XDR9<8qNVt#8T8WCFH)nm2!)h;kB$} z8Ctd)j#xqRNx~nO;dRhlj{3Kr3~LU#Pon+Tg#UUHulsCowR~X}>iIl*flc@6Vf$n)T#C}0QRKSOYh z(Ic<~%doU8gUD* zS26zoY80V|yA~o^M^V;7Jf=KO)-1&9sdb#R8$AyE=aYW=LX>$dRX&3?`bQDQ@KOsL z|6e_W-p){NHQ_IWL2J>z!CLISxB{%@*WiEL>Ys~P^Xg4_MEIKSU%e!^!ZFzo@R{cj zw-dho+#ryT5Ptt0js!l+nIZRrJ|`pt@YmhcE{~_ zU+@~>3vKrTT0MNQ>pjq%--Z3$=+y%tClFe_v7gJK|AO4bucA*`4fa6{_-KIP>ZskO z;JajiI_!er_rJRY1c1IPpbmQ?fnXO77^J!dz&8t(6HtRa5(nhsUP_SK6%Y*iR{=HH zH!(qfJs^CaEg%H+djR48hVUOUU`M46=%06lf_@{Q20JiepuY)FgMF5|AlC=Ped6mu zZb;Y&%4x7S1OKg|nt-jYqQFXrotlP#H^a`24m&nY0AoO>sb+vW?8`I-`EEcR_GX%a zoJ!bN-2$3Egfmo2kh4`Q$ejrY{}Kf|JQ}<{*9PRdum_~81+dqnt9;l4($yl^>(SLi zu+xKkQFns;2<-O2f8P);fn6V6JqD=3&P^APmjY_AgVPPjNw^C3 zf^^u~L0k*_K^lBRz6Z$bpar^G53%d&S%_Cx9@rhy)N`=21pgaFxB>QxGZ+4A z8nClA1~5&#A8>{?9&)n*;lHi5i6GA+T%=6`O+Fy>4E+BM^b#QSj5ZDAM+hI)W`O1~ zKpnnaKNIA~0il;*Hwt=;a5?NqL0M7Wj($$lME3|o_SxM-D9V+M(!a~@of<6J% z)ehLL($!0_U!|*;VaG~`y{5&0rLb$ItG%#irK>X7vCvB2H*cjJfS@c`s0KrVZTdLrwD)6Hh}(L zguiNk1O0D=hQ1N>I-yN320i@3Js|uVB+~I~wK66EFt5-Ou1Y zgyHP?&w-i4@TmANf$v~AKYl;(N5h&IhdqyAC#-t-+91P4@rQxwV%QA}U(76K*b{#o z_@xYc<4?l93O2tuEPqb}9*^&<#9;w^7WC@@>zqTyY@oX7B@20Z+R7ZwP9 zvf)7BFJ^d2!$H7&mf@uh2Lpc@L%bCS{N;ccM-6k}zJlQw8V&>IN|}!$H9FEV9fla;dr=z3>Y(aHLQnw2gAD?(!ksU7&kw~i#0KG zFT?v9vcUX|;r$JHxF2X32K*J?orO$j7y;#jfcXAz!zkdx4Q0T`@VZjmJl@~|KGiS| zn%@G(&C?B=0UHt%fQiIb;HM?F!QBcNGjB?q26r37-4Y)H=FNbZa}#I4{Z>HCvxzg| zej6Y-EpZm$?um~9&PbdM{CpBTOTd#8_XD1i z_!Z!`#DjpRCLRVnE%7Me>50byKa_Y9xtx)B3hoaxJTvh$FlQy60p=qNKbCkF?te)< z2Y7bkd4zr(FmBFCya4yV0%BAqb^@N4cnR?Q#LIveB>n<;VdAfV7bRW=yg2b1;HMI? zIL2n80r1j9Bj8sOO@LobGy`6nXpLj028^3;B-#MKnb-}Oe@nat?&}zCPfUmV+lh9- z?<8gb-jLW6G~Wfps7dSvcvE6;U~UG)cuDL7`2EDbfVU?01N=ea0KnT5?*h#oiTA+$ zBZhY-4ut#1iGu)lBn}3=J24A1_W)vaB<8?2-_0~))4|0jm;ZtMpBT@2sTxCHq30>;gOjXiL` zkKxS5WxyN+7&C`7u7LYsz?hlc*bDb8KyY&7YPjbxJgl)Fn7M%9=f*W~9{~s+Zd?oZ z{Kn(pJ_;~qj&3|2?gb1x8`lG~kl~`nH1J)3&>I^wa90^_Ys><3Dj+zjF%S3YfZ(Xc zVYojG2+gOl0QWh7kQj|4a6icK;l@#59s-P+M;oz2WgcPpSmQ=u9tVt@CmKDtpJez{ z<2W$CVffp|&A>kmh;Q9CPQd*P!)F_}0`q%@e`wqW{BwZ#o^Ru6a6bhZzS?*$@PB7$ zlIH>cTH|@Z#FH1m9b?##ya<>C!({Se;2Rk>B|i;(ieXFgv%oh4LMkRNg}W6HQZacs z+-(dylUKmKH2DRC^rH^4kWJuJT>_>z|)dn2mXxYH{t#;!!wiD z!TpiscEGce*8~1b@&>@OlQ#l>Jb4q~xyf4q&rjY8ctP@qfEOlj2fQeG2jC}@KL)%c zxdZUBHWVfbVR29&o>= z7XbIiyFX}|rk4PhH@ytFqUkS)yAlw(Q`27oH{d;>xG6Nf1~}RjYk<6EIF6@*z}tXW z6E!u$y@}x#ycrZT6AVvpY6ku^h97Eb1^&Yf|GB9R_%i@w<|9qJ!F?vfvzp!l%tsmi zOVf1VKL!Z-+0+jA*?^FrO*7y=hvB(Rdjj(bK*-Xjz2H8d;e}0m19Jgj%zUzGAGj|9 zjG0e0?F;wCfHCu#rv2dlG{es}9RSQF3@>YX7x0%dyu9f>z<-Y6=bH`${t7^7K1~O~ z{RKd1K1~P1{Y5~ms+wlOeH9@3w`mUCR|7)xX*vwBdrgPKeIvu0n&ts>GsEvU z9SQs`3~y~Z3iuxYLRV>80QYSSf7H|o%IndM(_wN|~zG)3G&oX?jX)W-7V7O1}IJoys9S?YD zYCUKU1B{!wsWjY&1IEn}sSMon7#^9*0`q>rm^mtyhr0tXW)`G|;hqnO**{f)`)Gy> zQzO81G3-u_0>6mi;#3*;cxY8%{nKxh%E)8HOvSil>radT4Y4B*SDGvO{V97~-A%tkIz^!4ha5FeF5%&W%!BI7lAn!5d5FI3hwg& zW9Gut)o@<`h*6Nb2JVX(UYzIS&41dN%hQa8f=CBT^ZX6h!mzX2FC*QIWO`&$hEEp;m}+ZkS; z`XTV&X84`d?ZDr_@W#{~z<(DoW^PLT81C-@#>_3L9dO?a7&Et~?uPsOfHCvK)KB65 z0mIu;KLh4=KO^lxd#y6d`~?L z_q~8v@24Jx`#y%hNIeeBF9EUkPdy3u{S1GVdJ32a05M;uo`(C^fHCuM>KV8n0>rGH zdKT_S7(SMI4w%OoKACzR_$L_tCiMdFPceKtwG;T?GW=cYCE%X{#C)B48SZBpK9~9n zFn<8Ve4Y9$+-VK-o86MR97GU1T@Zjd@z#qbJc5^%MvjCx4HP3*1 z4#UHm_k??H^IpIo&TwAy-oP9Ih}CZMK5)Mu5OSk=U${FM&Trlin4_By0A>Nh&gORk zvk(wkR`YuRmoy&;%+<{Y!Tn{1UuixVm}>x`CpXUm{95xIV6Fwksn(s@>#cw% zxBd`tTkGwBXSCh{_>tBh1D?~m1Mm~AcLQGB`cuHqwEhh6iq@Y4UfKFfz-wFY2mEI1 zuK>T@`XJy9tq%j<-1;cst*ws(-qrdf;7?nh0{r*ZrvZP}`V8QstomjT|ExFoR> z`gSwUBBqi}fXQSd;JcHAe{b?K!1pCT2RJv`3TyQF$+rN0BDovj$CGV<7bd3zelpn( z_^IR!z|SQ21iU1<7vN>dy#YU$+z0UU$$bH@OzsExrQ`vCUrxRY@GHsp0Dd)jAmFvh zgG|OGQkNt$CYibnFqQgT0^jAH)(@Ne1Jh;!{(9ORz=x(C2KdOd!vPpbo@z@2PHW2mzNsw>_~thHV*6X$h5_H!Rsh_+ zZ3J+Swo$-;Xe$H$W7|f+x3_tK?`Rtbd}rHc!2R1M0RO3NE8x4^wgJAk?KHsmwS5S^ z_`$YDoDcnK+Zlk@ww($1Z*6A*e!J~sfZu658}Per=Ky}M?Oec{+s*_0e%l3rKWV!N z@UFIt0q<%1G~m5$p9Q?H?NY#Bv|SGP?`>BAKG60Bz+bn05%8h5s{kKqyBhGZwrjAr zarB!mNt|mIzUeZ+MQ{3C;(WZo*l4aW3*Y=Tz{PKFG~Y9yeCyW%KlRpc;za6O+t&le z+j{^L?JEG2?Y)4h_TvCs+E)WkYwrhqQ~O%LH@6=TXxbYA-`1W6+`XN?FuzB87T=EF z0{o-qw&Wq-^pxkNx4E#>>Cs6J*FM@KX`6J@)H2(q0o#qu#?lk`i%0HXr zjAadfHt`vaa3^NG3TS3D0j6fG0KR2L1KiVQe9gRM-Uj?jW_M7&WcC0hzHpDYFPVP? z*g7Ov90sJdwJ}6%? zM}zVevk-A#F^fR?idhWGSIkmS{>>Z<%DHOV%7?knY`7>@$#$y+PG9LRRDC4nD&A0=Y&ww%>y9DXPW0!%lA@&Wp8)9Du zWkc*MplpbJ6_gFJYeCr%`x4S=h|Qj$d}HIqEw{Jv#qC=KpEQU+}_$wxi#3bobGjqqiOXk)sdm?C<K^Mpv-_^@y%+Dl_-l)wSp3Z5KP_%qa@CT3mUb@PvGf;9A71*@ z(&v`GwDi@bjXnR^GpFasp1x&Umc6`e{_>vXYnNZS^3j!d^!}pvcfAL%>RPpS)yS&T zR$Z{_s#Q0x`su1CSG~Ndb@e{0=d50``uNr5)n}~!_UhYL-?RGPS3k1)>D7N){p#x0 zzPI(2`_AiI)PGz5j{e8{|7qZT1Gf!4H85k%F>5Yb^Yu0Jj~zKSxpvRBGuK|e_P(_b zu6=UtJJ-!#*SW4|-MV$Jt!p}Nx8v3w*L(cP@s;B*J>k9+;_I8&AGE$}{f6};>n~b= z&H7u{|7`t*AAIeDA5C|k=$&}xiRYYn*NKmu_}qyvo%rgB@5mgKIWluXW+byMb5`cO z%x5!KW*P<$8|)suVernu`v!kK_{8Av2j84MCi{VGHhXXOh}>}QncU9YUvqs!#}B=I z_=Vx0Z1}~7CpJ90;gCW{;f%r!h5HH*7WO^qz>~&KI`yPyPuena!N?^ew~hRI<^V2dmFj|5A;Ow~SZD&l{h<>Ajnd*>uUKD>r?6)6JV6-1Ow8 z|J)Scyw~RaHXpXRd-K}Ona$U2zG?Gao1fYI!sfqhZrIYcW$!KLZu!}k_e~r+apB3o zICT*122fZT-O3%+|uz>ekb@p0)KSTkqfc@YW}{KD+hhtp}ZQ)G6Jk zoO#MQr(Af-XHNOtDX*Q9-1ZOK-nnh@ww2q;+di^w_Nm!ZH=cU>sUJP{yi;E}^>3#h zd)l{8d*HO+o%W~GW}ZHLdinG%r~e7pFxnGez7*%A6A=E`hxo=h*wIh?4)7lm@3<0n z;Y8weoR!3F4f+Q=mU(F22LW;9!u^XGd}s~-!ni%^;68wpCiH@BBmM9{>{Q~EMs3`U z1B46HO{^6hLHUO@2+l`ZH_i&-l?KQNoP9{*)It(x5#DMBp^y9v=Hl})g0H}i{Fkuf z{vC5YDtjZw@=fM0vjev=9>8sk2h3xbY5s(#K3>2rkr#1tU?*;g{28YPUV=pU58z+M z&5&1cD&Q|>5gvkAgnMz%Lzb?Dlw1kq6@Sz4*B0Au-W0pu>=wJpygBv*^Oo4%xZQELnU24=;jbNk zyW?*L{`QF7Yxcz7Kj3e#*aNte_dITYJa66}`#mmK|K7YK_AEEZq2@Gh|Ig^}9x?GR zjIEhYy|^%zn@)ruQT+M(dkKCi{F2xgIQ+`kHB5hH>>KR=a_oBce>rwD`@f^{ZdSUR zmG1lM|33W07vD#|xa5Fe%6AX!>q~j=)!#&1@=e5#%!14$)t^-V{_qq2pY-?L`ukq} zeV_i$)Ze4y=ifl|$2Us6tp4WpcSch1d+G0u`n$PR@DuvGRe!hX?`isb_%xyG*WWez zyMCIKKdrwR{mmkr+BK{Gy!!L%AJ+H<#TOJmqW%%}kE(xE{Tnr&r@!O+JE3$FO7~gC z|9HBT`(gckRDU1W-`Dgv_BNqw(BCHgZPwpb{cY3V-Sl^c{_dr}`{?g}`ui^ZJy3s- z*WdN}o7Ufq{$}+z&%b+^FSb*;_ApoJ@73+sUQhn7v)`CU_4jf8eNum)(cfqF_qlfA zkLT6@g8uGQ{QBLc{%QTq=+yRd{%+|tZ~I~I->3hu_ol>^tDj3;*S9@(UEfapzLa=j z*~|F-L;DNMo=ZH?za##~{_U~nyY^~)^P0UIpYPhYanYIs@cUfi$~8OUH?O%Pe#Egm z;>R4jJ=TBh9q~NeoAGzR+8yz0*4`2CKei#+f9&4)+XsJ-wD%v2vLCl1*>~J?iT-0x zZS7mW34b>w-gEpT?L)^`ru8k~tMRKRRQdOb6UL@JdqQs73;3J6d=P)dY5#dbaoV!= z#cBQPH%$BL30tQ9>-v*`8=LmRvi7DImd(K5NuYZXWzS7}OZtGuJ<~TO-j2UR(s#t4 zJz+=u!t@^z_Ph4yyUI;ZpSV5t^ocv-ZG+pJURm6beEP&I+kY_lT;d0V+hg=Qklh{| z$UZi`iocVykG0>Hy>t3c@H>#*t8r=W<)(q`3A>Nyl4!>`{u)vj=blSkoZB9|IQLll zUPF(y?>lrGvZi?EaUL zor&L%+&TT7#V@yC)4Olu*0CM&^TsaR{kH6G&9`OC4MWG@IsIqeoztK6cEmfX<%X{6 z2Y2sV{?PQk<&WU+vFUrJQ*Y~A-h#h3;cpuLRI$Tr~bMC5-r=y${iPrEx#c^!Vr9r*oI`xB?_OdN6gbBVs?7pMA` z!~O?L!x6D0PVKdueQ|>Ch}fR^+Yf&;@prJ+$zN{H5_%0PZCGjo=UeI#!f(aDDe8o`gzI-MJXHA->znZD$IffEY3gVQY zu5ziGDU|XRa^$yEnRcK&l9zmX2T#gp1=(4tWF|QH*i3O;678>63Z>ydi8QO>{1$et zs+7m_m8wMJ8c|ub*i@8&Q?lyGadl9dO^ApZNo)B2ni|e@A)Z-;i`4!3s>3j1ATwCZ z`>3vQuUa1Ms^HRfpYT6bxD)W^Z)RV(A!YPqsBQ_2;oS&z+EykH@@h>OdW(M;9R zP^njCDqcQ>p?Z9vT=J2Ni{(tUCMx5?afPBvnNvpv3e{OfR}YSZnKVGSCX8NG$Wp6< zd&BtdE!q4Sg>dBVE!BL9Dn|VkCPapkuH%(eWv?JHEiWy~d)Z213=LJw?K77bN*m2F zmJmIZ&vliHMR2gqdquu7oCl9k6+N>mQ{Aw*P$V|1Wh+XGhb7S%=KY>hF26;|8L?u# zSS^ed^O1o5Vj-JX%Eg6zF&A{(Sc*G_Ggv*IuT1n}tYoNO?Cah#R>^zRPNu6oI!5h~ z58xJ-%f)=AR7=W!O}amuDXEj|&4qS+vLav2&UEam;QXEkSP{U z=HX)&6*9x6vR5r+y;x%^-wG{JDPK-Y&e84Dz}_p%cWz; z%Vx%WE@x)0SmuxP>6&Vx2xiK&q~NhG5lqi9G#JtN5EYOF$B6tpM&#TveVNUsFTZiT zP|1sM(oqtW22|1>*ES+?q@r4@jjrZ|SXC*Eq9mJ0*a%sV2$M>AQ-S38qKQ&ww2%!W zyDOD)rF&DpRPC&QdwcrwL-|U+l+E|$y>bx}$SleaWx$ltfK_0nd}R|THHzoDo65tS z;SWVkhI0?mp|~RGd|HYw5-*Iijghao;YOrLvjDEc@Y9a%&u++%X8N<3D74|bH;#j- zIze2Ysi0OOdToNjd6K1-UnpQw{sA(P3U=(F? zPO?+Z$^$YaL{)I9vf$`}c&X&WI4QEzd_*9Grx-~$jB~}PnGzJw*@bv49Nh+iH{1l~ znPXfNEAzSm7U5zdwNt#Q5jfJp<`^D_E+y9JL>Q^mb90+N%PlW>kg+VWxM?E-o5z>b zj-55tVjNV`d@(@7{)OX(BFQ4^9T}z4o1qES4+zjXdE`gc3ar5#Is_S?lXyKjH*&3D zD3^Q*SA%0(8k^MUG>f==RA5E%P9aeNkJmI#iz$Jg0xo?HOiG9gc3tQ|IUZb+$6|%GBx)Op83^VEBWj%>?EK0JsP2-l^q}o4rA(1k zd{;ysvR-uHQr?lMD!Obt@dS&hSc(#%w&ORH6yk1~kO;hv3UvTg1SKQo6&hhz2IDm6 zB)R28LwSmtI&ilRUCmY5@41Vc5QduVqli;-RlL|c?E=7%w3F2-W~@OP{B;opBc*cqf&XKL9I#Ua2&X>kb^!a%ax)(20-d`Gm6tissTAjDW!!M z&E~8%V&p^9f@;nh5vi6Q6DoqnxjL1yN2bZ(io_pJI)w(7p^~DF2?m!Y{&dQD2Q_O- zoAd|C!?rB>s4a4=TJ+Ea1`SX=0{zMv^pRypj2&>j$RQX-;O$vit`>$SZ0mJx$drb$ zhUyU`4CN7M(0atkm(mO_x|ubulI&wW%qT=X!cIRh?DRo5c>8#(HBoziTY5CJ zWf81i8%%mb#v@Ua&*gI~9FijOMBUbKI3g1%p{=RoH4ViGN+5M=SFlEmpuXxU zjg40g^(}Xucqz1hd~B>-sai7>CMlTXgmRJ~inZFcASLPhD9m5`2uYN#D~Q5*D8ye(kx$1zO%Be>EJHr&VREq5dEOs><@&K8f18?5>ZqnV--Sf6csi&j>2 zBcpd{2=%K84Itg%m8@)XLQxaQ<*31FIcl)*&Y4|Phqgv4Ox|?(qc9@HI_i(R2wiBP z`{|kb(P2flLXTQG#Q%=neO8yY5`Jc0wtUQ$XA^WW5A(mB%vDK~P+q_WoHAYHz~-KG z6Y0X9?r+!x9YPkw#`OS7N3xpPjVFoz{Kh^~9cH1U#5LQw<~Y}(Ix7+j65Er$xX7&-%WHWq4QMg;PD(Ik%QD8g<{oNRlsDy_khSF!%fX~=Ok|Pf(;BUQo5lx7WCw$>*Zh6Ww;O+3;(G>knd@4F5Dp{OZ zDX?zB_wu%=$9U^TA2D$x%?_oA1lSa93Y0QgJ2+YA5DDKw{zwWP92h}!+?C_B^Nphf zyw~q6xTd#|Gr9}O>IUoo7#g(s?*<4D4=h|p2g}94P(eFaK?u7j7O@yNqhn@y87rI> zg%T~gFayvJ%U}_)zH=atZ6Qb;HW&J6Gc(J}mGltXX?PEt+JWcE-tlTk8&*Gs4?ynF zudY}qWsU~5n72;Qwou_oe~=l}SJypmknZpnWSW)u8d6G7P+Tlxqkxw}{TbS&PgHf# zL@ixWlQYrR4d^Y^Lqq8DVw}rX=X3xUvJT$1Q>Ch+ixCi5K`*+cf=x;~Fk*uPJ`N2i z1db+xv&shZp-oB11GLmiP}@)jQO7#Rt7V#kNnh#2p_(N)6GBTO4n@QBSPl|#s3hA1 zYdwSy=fz_JHU`?O1*yK&-Ky8&hJI9s;L<=0?tgxWV0 zLIn;XxYNQYsYr+_P|OhC)Smt^EOwGU2GNztv7;+v&j%3)=}rR;7X%QI$cc=c zVS*t;koe`aR2d~+WA4?tqRiufG0-L1ybqJIjvZt}Gm#7xQGOsu_56y`Sj|R=x;Esq zBY9ZTQ5>CdF&Z)?k27L(7jEe*Z{}f8E{>1#xf>n>5(YIZbjFEPGFNPf;SiHhKnTGN z9KujxI!jo@!kksLA>6DEOGZ6z1CGtE+KR5q%Q)>R;h+RrVC-&)-&{KFade&f*sTpg zwzHY&T^O4x{=pd!CBY13r^=-nZ*eg*EUduC>!|olB2tqJE>Ywx9O*c+5kZ-Gww%Hk zy06G)JCdMor;#y41A$cDOk)GHAJ<+c|2k;hTg*|0Tra;V2*o`Jy)BSsWJGmDla0`X zQZUg7cFR+OR^spqRPaL9-*WYIT?Y}&hc9Gm!&IKFl<9P%KZzN{&SRp_VnMN{nl+GN zW3Xxr6=3k}qa7j4sAFub)YN74s?sl_7o^mT7`@cK_#xjwp^8-jA;d*EYg(oq8wv^f zIR$JtK*Gp*7H&*VFoKQHLb#yOF(XLN^#o%C!qNrL*Miaz$fG^A2p1mO9A#QN0G&F( z#Rw$8g$?*^F@u@d3I%bNu72J&M*UD5H&QqoEfUbtlZ!B12lr7F9q6EFV5pTTo7W-n zJ0d~|o)InyWN0GkhcSL~;BwbEOjGN3p`lKt^dqek+PvXoZ;&}yp~JpSb069MsmXah zVX;o_?E5H;q?HSDo(@M8seOkfiiEg0Eb=(fej1(`UZ7)tm^j|ba~4Pto-`=8=-R+; z;B!I)IKzi-awHtc6S>HT6*yRw8Kw;YuS%zjGPL05NfecoalgbmAPKFr-#Ipv$BQ}J zf_aHSEkc?f#7v3pbRsLzV;NZciWBU$RiNTAg6e{D!l;4G-f(p4T#Xuv7KxIfgKGY! z5O%53Ikz)L`U$OPMCT?}U?0wJR>*@r5z%yf2cgyc;U`KnI3l9`I2f&l36`Cr^`PHK z`3Ybs8?+c>sBPFWP?>NoOGprT+zvV&Q463t%-l3ldqxA&I3hVL+DS+()j3>>{z}(D zcW=pOafVnArJ@w9l?e}V`Iwt1vf!|62YW?0wI%{Km0T3KB~sq29}NVQlc=*4OV5rM)X(V=<(1Dg`DZ&2$94)5G#tLm=P?c&q-1y#7R*T6PIc=lw&$ z6j>TlqFc8$SxO^8aC!L^(4ytk0uMmOaWHt6J*-SxOn0UlP~$nAPZbNPuStnt1|E$P zwm0WgYr-LdEVel)cXzB=lY&(m2cmH*S{YpJIo+GEV@fNz4y{R~-E0l{gpLPgqN=X$ zE!f2NU@`N&0W52sqqm|2ODZ_;4~3Ef18x@%#nkjxxYJ!}i4&Zs$CC=d1S6-9B89U7 zoQU5@(l*-RCR7->m;`LQCc zYkA(RJh zcaj#V4GYy$0&N4}yoYP9a7dj`yio@4UkHOgyC%Jd|=6Tv#Apn>Q~bd=IDqx=m@Cc(Ll$y z(Vz$uM@ho%`+DK7K_i6WDrlXZ2$F>;nimrl40f)_Cd{3-$-EFAT@VbgjT{_Ep^gm_ zhZ;JZEc!5*J9V_53Mh!$%Oot{c-bhz*@Ge=3;@4g3)lZA&7FjgN<-Q12sG`w2g^EiT#K!5S zQkvQ>uS+S9)(1R=I>bO()iEq@+|?>-R`RTreI4s{8;yZ5ayopvP=YO%W=+frX|Jd6>c)asyx8ShOnL`&uSJF70yNm;up-1pb_rWfi?DaH zv^)-Pp+wg%_28k6VE9ZGg_A>R$SFNz(nUE(x2n83Uzv4?S$^^a{^?KJ{;pWzy8_5G zc5@{{dc_KO2H;z|lmSsKU78*pwZ9IL_Mm~EOy2a#CyVAUknDfrqRl?2+Eh&Z)Gjh8 zROq-KyjnPv8%D6R18zDpfW3f9ep3Mll1;iqwvu$d_U2f+=<_+dT?gvMB@IigBzPo< zTLz4{X=6rQyiJMS8S!C@MjTWOaZx3SNPJ|)_ryuO%d3#!jW$BkxdS>UQ<8lth{^nz zE>|cRqeGY7=wGsFMATQ0z(}PEbnvY_a+`r+u%yq3EYlj6+Znr2i;T{-Ss%RmG^ZsnKg4NM?Q9f+b^Xb{# zPv_`~nOu0#U5|F4Y|lCPuKIK=mj=rGQ=g)rWCJ)ye(TdH3IEimfR;FGE>e--`ZQ}S zkvi&Afe5EgIVJqor=bLxNFDX5K!jshoDzQP(@+9Tq>lPj{m>?{xJDz1qdt{x3k{Uj zF$t9(n+2J=CZSUSj$ExQpQH}Vz5`|c;q5YJ_Riww3{0hI&l&?Ntd7yZXTBy=3n`l{ zU&B|$153HO0Uh26P-drG*e3p$L((bp(kcp`o}iVDYVZr=(MV z_@01rpQD-5521Z|xkx4l(GYC~E`@^?u{h#AU`(NOwgo>p?vaM6qP&@SfJCNPmmOOO ziW;H@RpZrTXLQVx??$N24O)`Jq_fsQ!<rK~#p^Y~Utbbos1F7?P zkh*OR4bY#uVZsVL(4fHA#>9*aNl^E}1x*xf>D9jYqCwQ1!NsCoLQnc+hl;eim%?Vs zejA3UXPlD`XN(ROC;F=s5VSSf+CZVUp&FMK`btl7Qn0nPw-S^T`Fdfj+t&uvxzV8+ zaY+4~M2Dz33TLCqNx*!?Rwz_kK01Se&(F)Sy@l_=MCv9v*gB)vSa2zsJtU8lusDbl zP0if`>c=IFz$rpWl#x~KY+Fce^>j|&@(A-DEqNy6t8^*C#_2N4s|b^(N9$hS_9b6v z2$AIBN|PhPvwU_p#I2ABlRPa$1H1k(r4e2~goQ`l;!>RYDeZz6Sx?;K^#UBrQ?_oX%x$4CsUbPY`DMyKZWCf9vQYMNS(YB z#ZoFy*G7p*44gzGF2YgCtS)2SjIS>exaReP{24jA0Zd_`28c}6IN70ki*1c437ZF{ z5u$-o?I@nB8bPBxmX|G;)%1OBiJ_6z6i{{vwNtd!Z4*u+pRxO%9U;@F2a!9Pf%<_{ z8_>eCdJB>-S!8lKy0^zK4e5g-+K;BfXCx*I<$kj%QTm?g9v!Pr$mvhM{Tv`s-GvL{ znZ8WH%L`ldx_6E=cV-?vLP`t}I8CaS1}$zLyV|%j#yX`enN_K!w^t+&2Rl&+23SP0s-VjpzStpcn)gLN!=bE|j2T zkK(`q4W=IN1NlnX(b^+4G+Q9ddLb@xVGp&nX@-lcRT+TwimR?wmd3!58R@QYUugSU zW3{JUgb7aG@zSj6EwDg;+5&O;c$`YwAw1E`c?oE!{#BJ46jAkf*jL9@CaDgk7se1x zfWluZM38|p5>-HoY3&18qP1;9ZmUEGs=S02LXn2BORr#UBcr|}T+e8DsEX0x+Nwn< zA~lMTC`GWG`a+-Ukx(h=6niblP`tqg4RC&C|>CAIABM?rW4Plm2ynZLy1!0dkS=qfl|`@yiDve^fL=& zGNVR{!=;RE*fRv;V^e*jPnx<>DjE(FjDiYcGP#r$_u0%$Gt*9EayB# zg(ui@{xf-;n7ji+PB~~U1;!LayW;)hgUH@!2u(}@Y@k(` zt6j^m&mRZ!PN=@BXVP0ni#o-u3-&9OAn50j7AR~-ATT1L0%0cfHlJBX`VFQ>YcX>^ zAMYZBc)?gEFzbk+IgA|)kSxF5XV%r{Id0Fo+*qG}o#Q0V$oH+Yj6x||xBcajMw7di zhQ$ewH+K0$iM@3P8HWU#kNtd6x>m3Rj+)S(h?arrrLVA1)|(?W!BljfLwPdu>qgP) z;fcN%m%u0+WfdZ=L6Ot}3$m28WnGaeW$2nC-I-RIW`m$Gih+{u+i&P)4}~O&Sr`TAK?~S&pwe)iedu zS)uP}MOFnKgH%~&S(67^peS54oYb>*_M4hZ0375NHu!?AY=rztVp4eBEXSXe{tb_***O)VF{z)kwnL2n6r zfwUtj`{=6OFD#a`BVFaO2`U`+BR3R=G(ykNN`99>jw_dN>+G2F=NDa7$u(-h{KZ@|Dj4 z%UJTA^ymnd)_CusG~AybLub?3JUTRL-JHfi1q&y3@$!pZ{`M$)7iWslDV2uyURKic ze0V7sdoWleVa^VO$!UiAVJkB$aR{|St1!3fVNu@8IF?`RBH?DWUY@_5heB*SIgH2{`d$-f$>T!IyL3+v!(cOAZdD!&q#%lE z_?bhh0G(>bgv-hvRXXVR!?_H8FncMK&$PR``#yPahRA|t<7zT*Sj|LaiO}Sf$>k6Q z(*_5RiV9(^U@67TMe++kWhI_g7PVgC2%P2a@B<_L!eN#&5=zz9HBCQu_Q26%tgOW` zGb_9DBkch`j4&;6qtrWK%U290dwSSt6`wtKvziY38oz7TfcRF*0H(84E=`Q$U=Yto zb_cCCMa+q{Q>R6_T-QY?7=hV}AKJDJ6luhoaL9DuTE^ydnhva)PLJ`qK~iAbiEoT| zbY#{N1Cv^@#Dnwib?u2Lot>YhxU^Wqo{v?F{Fk|H6V+>8EO0#=!-XU1@iCpjP&~3H zWJuJww0)P0vm~(n>Z$}Ji&3zdYAi?vIbu@C@yo9&VaQUm#&mjthm#GN<1j4f8H1py zmgY?tK4C7aB+k3<|9|cd729QZT;QpAzk>< zxgac2OY)@WO#g{XItoM$$YMU|wv!vNqkM59&{0!Kl}a1nUv1F<#wAkcR2&s)*GJa0 z>u_Y8yU-q2@e3I^V>gx5FwCn+jDP-nB@;#h6FJ9!FTG)mFz)*QUNVqVub+(He7kOa z@bfNPe5&cN7K~$mbo6&u)thp9Vo`7>4E=ZkcJPtAt|Se3K2yg({}aXIu5@>-{zqyo zOja)`e%*HFBt0d8lQz5t@1iw@Vi%*&5==ItBwSj=ziU?OuhZ(mh$R2`Zu6vcuh%}i z8l-`oXoi?Hk6jHdoYS=O4d*nOlcSqSz;I3!gz^fB=N~E)j=g%0sAbS1Tf%U2>$zlw(pd7B3 zYd~_pAsPEdWF3piDT+3xRWatuJGnq{!ek1x;c-002ybM7>a)J}2Io|A`>%{KnM2Df9l8)|2>xuC6nmy z151a#2MPB{ z1(I{9H<%(VJh6p|a;dAPw*Pg$;e?oH)b$2SW^2^Dna04|Nl>f z0r7{8RDNca-z6jEUFhsMc zu&LnD{ojQXoI%hZ$cMu;2d;u1>=3-9%6L4xjL#!sd)^Y09V~*RlzpT|4^sxx)TC%# zCOfYoM4+Yt3W+WVqCh{AN-Oc5heG^F0cu})r&8&FvWKHJdH~Brl0yJXsng1u%m>)c z4X0T*ARNOlnNJ)jqkafn-g=R@`21acyPF*iXdLsAc|W$Yc>5<3^)IhC-C29-HloYO+#H z#_n~}3Nxb5-LFeJN!|g5jV3|d8^u}+&oTf5a56DBSo01ks8NXICql5k7{YS4*iRJ-Z06AK$H8CyDQeFQEr(aA=2A;9v=CE&9U`Qg`!56(mrP`^W(_*Uw0& zdkc>0c=Y}kuA~SpZtXC?_Sb~kZ=LcR(ViYt<%cY+w_&_Al2;%qv~L;=(&I-y zF;48jzzda;uil806BkN5ZuG>C&BDdP0)a=bts8!Isg1%ZdvHp0D%O3_!BV@}5RLSD zDy|^o>(9JIv_nTxwsDXuTMCxq>@V>my@}1OCdKuIg3Cez_)vEZ&VB8#22bYK8dUfl z7CT-gX)!(4L~!07kFGGdthlUrN*3YNPW)kCynU`-w}#Rur)?upk9HNgqVCRsWFD9& z1R=a6_EGz4Qizn_1-IP_UgL9~)V+?C$dI4U(RLucG^mvf^Eh3}q{Sb$P3(6ZlS{+b zExW$@V(G&2Em{p%GHk{0=kNF}Ff=jFeGWq!>Mcj#Fy)&>?3-(_@yra8PBDrlbF(%x zv^&@;Ls7?vOg8*VggC(lL_o|&zr-3avC#K&aH@}^+F6*n#?o+=aL7K3jTzK1txhU^ zZw1dMV$G>1d?~aBMN}$_DO8<=m3!fmq;+>l+K~?L2&Wnimvp0eO*j&ubqFU5g@Ql0 zW=lh*^z}5-Yq*i99(B+}t%p8yc#n{0mrRibpGZKu`FIS`sN{uvp?Iyv(E`aWpqBdObWhPNoDitUaU5 zq!6Y-6n!;{Cbh^!7!Ih&o63}?PHhq)fXAuQdO_jBimy)X@fldxytX4FOo6A2`OI!@ z7u6%=MvDg2X{jhtxQ!y=(URK3#I*&(-68rGM@<`qd!SyUP12TbmJEDP!yP9lnTS)+ zrHw2Og42smE%Jg#-2m!WUp0WtapNe84b$>OT8G-l6FpLN6F!a3pg%Gs{4BZMFluVJ z#wReLYc{r?kq+zdV`$xWMdFGcB?^=~5?HrkBN+#J&gDa&5^>EV-$a+UL3P4pLfmE! zJbT2SPIt?NFr7!|%yq+z<_WoD;|?N7-||RSB9}LHjg9G$+~0h=7u#%pPlqr>H z3vnI_!4Q-zd|iTK*Fh6?s0WBHgjnLMcOg8*6bWG!8@(qURwj8sBaMJE$)dal#i>Q9 z`okzUVr&OT7+J4xYi~z``SMy69q#OCc&MMF!8QFECD0Cy2G|abhS&~`hD5tDN)vh7 zDoPUUO;$?KXi+L>w+X%-7A4a~Fiok@EGAEmh6N3=$th}hDw1fI}&2LaUKd$Ug0>_ zO?b9+U`sP!$vG|k>YqKHrCwy0uVBgQ7||A@21^+@ z8r(!+%Y}&3I%xi08ns)5KRTqbqIlO<(IDGa(GYE{Xn?j>G(g%binr|*4T-c+lqA{$ z5gNxk$}FzB;BMZi!T~|DYoWKbOKpkVfjab9q%4T7uY>u0;$HBuW@)=Mtw!N=1urtF zo4QrkrHWZo!o{u37=1WY-gC8935QUlyV7Im&{c8q={V8@jfA(AQZnAgQ+Hh}d?ZXv z(u&3pz4Q=BKNQSb0iK=Z-*C13nCjBkBCs%YPinDp;+Kk(4pD1Yg$*&0osv)#Ke=0~3WX30gb;RU zgpmBP$q)uhQ@&7$2{440;SxfrSP0?VfD2&*yJ;c3jM5Ow?m~r-%HAPdPnbUfJ6Rzz z`IxSq0sRL|1iw5pn779Pq^-#oDx-|pTOU{ENs1;_SRL%PQcuoK|18TV54DQ~n)T%4 zo^S-3neoUAg2$5D*@Je`ND1PRW&=e_QMq7|_07M?C|n=;R#DwrL}aOMuto5lCHYn* zbdQL!U7xJ0u(3kd)nvG*xl-4X0W66{I>S>bN&^!4x&`X!UlE1p)CR=D+6boc~WlO%4sT&G2RWT2=}&t5k*xnn*|UhlXqp(a=bLMoH>4+UpQWOGStR+!5fPNC`|mu9=K09IZC# zRGQPy@%*>}Dc^bew#%q}g5ABa4@KOWg>Xh~7!0J{?dEqCEppnhQYlw#a(oColmVVX zBLbE;urN=W(yq=I@|F9*cV6tVbde_WXL9(iFXp~p66ia$p?s>=>BE-A&S`H)9<{JBxnIz@A#sHFCag3Jv^zg!O`m&~!N%hb2SA|8 zyUt`EfBuucFQL!4Vf!8D8yw5}c4CK;9@RPpzVM)ZNsI2lYCt-ek+v4{PzNg9Rj3eG z;CU*$cBqMruPAFfy6sw54A~2ga+bC!rzCBND&Z1oIB8$$k^pLZS3Z|VuoE4UnZ)_( zGh3K@9B~brd7sOryPSRr{2(1r+C2ew58Ckj{&U}s^K6gG2_HINJY>_Cl?#1dLs~0@ zw?k5Ml*cWN+kD0;&?;WLgb}&!&TM)JYTg9iE%NBTFez=?h!A)*sL|^goOi-2GhP{= zJqM8$Q&dq;H!`t}#G;FE&T5JZ=;uatY>>>Q#Bz=VUv#TxEQ9-45Y`VMY^`lpiR+*x z+d3KtiR4gKtrQPd-yJflCDwMKM5w;5y$DginL;7K_6r>@U@H5(AWz+NqQUjeFy?Z< zN$t^>#hAd#l?i+eH9#8b2I(Ss1dJZQ;&1m_M^8ykn9Eapgr%?K4OK};(U6c=?!@v- zr+FEPxR?VyTf`t5KwXe**s`S~E0nP!1wkh_6fv2GB&n&of%bI@x@CO%_zpcg%r4bG z{MMP-jh88nj#9~1vkc>Umg_o(uXSLr7Yr_$`(^D}j*bZiMavZ-K|{Er)<#DdKbRbe zgf^QrAdnh8o9TFyJUrz)%);`P9{X0|n$lpvM-8uSp)dSdt*H-h)s{zbAPTxtwmc5= zChoCfW0+P2c zEGllX>eOWdB@rZ1%HeVUK6}VG=hKh-SjK2qu=`&CCf&%K9`TDjt-BOodDZtU2kU`OdE& zbR$XPaL|kKnKp(Fw?>fi&FNuQoKMb-;ow;TG7YzCWX{RS^+ocK2&|0C-hlh;J0G8ee8o{-oOtQSXF8#J z;k5_50J0)Ggrx3PihvWX#xF|K9cx-W^+F}Ug2G=vVA3lLmzV)m64N|AvwtJok37@k zDm+jYZIr$kFW*nV@0{7lmWwL=<$Qi=s2S-DFd85uMyWJL5(W+n8X7=7fiUt9_`$)T z02)U~``Q1Ht z_$NSpEcCr0(dRfL>N(t%=W~y$FX3~y-YWW1?IH9HTo1|;`wy-4heG*txdVml2t}n2 z=4$on{oQ`HunI4OfD;@j^S5>9%snjZol8O=ALtbZrw5$v7_jOwa~vI=r;ie<_Uhw= zJ!~A)zqwG&ZWt)jwnvdz(qWJX`v=M}7*QirIF(M>%_cEW_NyQSN>4075uyZ|LQTBD z#|$m2Q64>BnV6m#(dHRKtSDqFWv@KMQqhrhZ=v()v?SD)k_Cdw3tjaHPEK(kA4(q8 z!@Gg>;vh*-p2J0ti`iE#`Nl?R2 zo_L*tPNn8OQ!n6D3a170t0jsY)y;PyAv%sk!=A4(Xe4-P`RTz5qL=}nqgZl*qJ~yK z_npH4r5C|TS2Qxs@?*Wk@ZG!%DfcC0uB{ui6kiOlB}aa>C|Ltbn*L}H4n7IXMFMey zmrD{2VYN#oF}r1qvJ=ea>2(7#=ST<~L40~lFH6bSlJr^QVYIoun8|vu^TYnZA71!2Rm)T46j&W1`?UI1fi135?{+pXPA(#GKREE_?dsQ z`S3>o!e}~AEO>l5LAji)=V%K4VhL6h5Dz4cnA=s<%4ic0>pc7zg$`)dbm#+MG%HY| z!+3fCIyA;be;x;`XnC`^fL9YhiaDo90myJ^VR%D7zB*RMtN-L*Uf%3`Ssr^_GzegE zSmT(QpzuSN2ZWuhoYQ{9C`L}`8R}$aQocCnMg((b$QKwRG@zNl_A}DpJ6QPb9K;Mk zsv(I0eqMoGbRf>g&^43X?@$x3h$$VPPR^_JqKMd%qZ{&8ped!<#NVIWOt$=r!Ra(J z2&pE8}ogN{O8m~bYaSL%9EXGhx zdt4v7MT*kc&l~wxepBYp&~iodTX+^8mhs7b$@pB=V9N8)jttS*ui(3bTMV{-O&*-U zx)m13(9paLRDnVXrb>VMD?q?-_SC*b3~9EPq7gP2Z_ro`#X~f-9Bn^k?VCYn1iB#D zX_WYY^g?tR@-0^(`b}280ci5HJ-l{9zO=H;FV>^|%VWYQlJ+Kit0j+;ZW*hffV6xb z!i`-TZJGqlqCA8p7CuP_3nOQhuk_+8YNY8|e^(JlIvG*SZ^HL2QJitN=H><~ONlH) zf%OBIC%Nj}J~R)Y7VK6rMT05}o~Q1r&N9{6(rTE^(RpMcpfa-!LBhO59yGz zRM?V9N!@4C&@E)cL)plLL?6r{W*^m0U9osU7y3h4YtCQJ&}>vNyX?8Z7&j!Xvou!C zM*578@hVyRQ~N*;ra1hm4+lc1wX+yC?u-t)yoj=I^0{qLzDA@%4+9L(jmh_D97A&0 zK-u~6m4M#L3NkyBbkjjI&Z5dxA=5)&HHQ&1qX#FPoaeIh;KiqDMH$jLNETp@5Y_=2 zO`gdFzgVK&i(QJ~7sp@)wcDmN+vqpBxZ$`0HDeWxxv79ppx7^zTR%y5nwUbB2nJ#h zc<$6aWU?f~&otE!!g@uf2un*@K;eOzwx1_no+-2$(WSE5;`=)p`VK`G9V5Val6e6= z$lsgbZxCi^AJ{MynW?NKlLy9)I7rrb)lRl7mm#~rpv-+3iT1^6nm=G%q1$74hnUn& zC80?`U+r|@_^w7&E!x6Hhx%6U_i?Uif#RP z6d*@boSm2}%0-NMTWC_jArWze26Bxy6|r(A!Eda9M+13SdK!MpK{h-gz(oHNsYPO3 z#wCQ1ptQP_IJyNbP#RvrQq#2qiX_UR$WiDv*#G8%?+bO3M!pYw=yetk3KPW@14Hjg2)2VH!?Vx>|=VrKBR?Kb=mC2WCEK2aw=} zD&NFlkzx=3q15us6KNyD*WjS+2+R_^hRzhbNOzQ3n#_NBKF!8@H!%QXq*JxiK`*m8 z&+i=Wy4y_-Q~?$uP@M58G{`)EH(^W%iJ#CozHl8<-~uGVg2QD}4!cBY(rO4Z(c*6< zaSVSt$?g~0jXhLB3k#V`3nY0I!)(Z4v%m()z<^)!f&kD)7cSRXghw`5eHHisvuNJ6 ztk#}J0qO3mFcS!aa!0sivq1w=a9~MwBriwJaY?HLe;{GYNLI%48rDf}dj!Tus9Ypg zVP3*Y2{VsVJRq>#fbi8bEQz31(!^)Q2F&ZweuvyKfeL@uj#G4_k9-g={BGi~Z1Y1v zpu5Goz%CU!oEl^ZHNPA-gaWg}C&idbo|O4l5zUCTB*_ zp>DP(&5UPFQ|3KT+Y{Kwsb-;=^IneKn=vQ3?I+p0p~$O3v#L!lGzk+jG;K;=yy_AC zxL>Bz99}zsIj)*B6WA-m{8GZ4l*2^HizIY1vxcY|Vs#c(38n&3Mm$;dsiBqH0bkao z#jwz6m-@rNwi~K#9|z!8^S#cvCDSQSXZm=E8Lew5tz=3greI1mePS7qDb6;zStd8z zFuU?dhD8A?taM3cmdVUEI1-SNZ>4T>;#-=G*3vXf@)577eG2N88X%eRp+l42Oy-Y( ziKAf6fOc|GS~hb8==_O*TLI!)S|fwi4}S=ag*z1p3DM|9`>_$xwxb%ktV$tLmgi=k z@x%8FF+LBWp@{~l49_Mo2f6@EQuHxMwA(m@1)V*^P_E(T)C_?EHjY(3UK*oy6L^>QqTTT$LxtgSS(elbh7MPnhz3C5=de7929Ply6a9udK?4;mm`5{} zkvg$tiu40eQ#E+`INHDWeYSeXqQNkwMFZ$_u93j5<^9x%#R5Ko=SNwT9~>VZCUI7a z1E106G;LB))3Y+#hn3J4b_IG$yNJjTG>8wDRs+q}ZD(FT{oX;SQs5dNBUuEV@$!Rs zF5}%MJkGNjAU>R|4n zDwDNgY0Sw2fK1WkBTB`9?Rh;TMv?yNL=klsYLidk%qA!g%TsWJJ1JHvO8Zx4aYh5m0>lt z^A4v33?1mGX5jFXW(+9DM{%wtm2In>kqvn`0b`GhxWd-1m$&MabxMF&zV9H?rU^po=Oyu}OW9(3rOLpu*TbncwagXYaWWbr{b ztTeBybMXA)aQ3`|W*HSB zOY=oEif6s7E2seRyHW&+^tGKiF`RU5Rm%gG(`bnMf(2_}@atlnfelDIAOnMkWof`4 z=zG)Ay#-nV?bwl#dw!01s$>4_w7tGn?{JE8`OLucW4rzm5@o1s$$IGp(wW(Z#aiomf=~<>@6aCKC z-#LhScpBfK&Ws%j=V&^OeLPZ+4)X)%h5`<+SN1pD7PcKk4aisIVy_z(HV<4TLRCpl zh)YDBtj7bG6>P4}35FV`pmogXFD^-p@pM9d)Y)Iq5dt-L`yb>--C?!mT}|2rAr#tx z(>&a7mLo#VG7r)dE0>NkQKNM^7B#81F14rMy40i^Kq>kGNHolfEZ%BxU{B=0{fWA8 zj>xHmrK*;myEu@?yigt)ma-7~5Wb6O`L&DTJ-23b&&p>ox?SOkef+|s5VZ8CLJ*&k zIjKNRJ_qJ<5OV*6u1&Fr+GuNkTq?MW=_Wsbn-dzn%AMj(zw^5-79 zX$B8ufrlLI*9ga}<;8gF9^ExRo5nL*9;~zzyfQ+$buT=4Fw)xeWU`4wLcQxmVrxt= z<{U#-0^Vd~0gd^75zJ)y@jQgL{Nkt#45Tc#Cl|T1kErRC*+(3PPN7q#JtaOAigZc4 z#;OJEi>4`$4{z|tRv$LuU=}wWove^i0Q0T98xr z88bGu=n%m!(%{shple)|?9`$_k7R2B#Qy}nMlJ{9a7@@YZqua`Yn1jarc{?%hfFOK zC^)-FWQu$+YYy!}lf9Wvmf%b_ZI|#825!f`0f`qxilzuyTY9|tipM8ex73uVjo65ar{L}GBbAzhXVXPzNe@i}^-K1#sI)=9B=2WOC00Gv zN6L9G-%muWtw$yf3{sMYTuAL(t~O2GH4{_T;E^}4w%8EAtk#BG4M()xlAadQqF}3q zbRmgHUTMq1OH7VzBd3BoV+Uh!W{dB5VXec80)#e}ZdKZ+p>1-OZ9H2APs39(_7zwW z`A{^F9GM7ltpVT1S{a;s(E5j%lel_WOnzWTZUfB3;Q@d+HsTOH9KHU9VX ztS*g3aL1bY^!2cS@jz`RyNU;SNAaj8R#RoITK9X|4O1zUFgi^|GbSW9D?aGDO;+&< zD2wQ*fTA=wm9lFYT>kcy6R|6VrSdY(&O>Mnza$WBPCuJPx|*+`L6+%Sm6o&q>WOcO z`RiF)srx?SJJ&JD4au`EfTXjk-sMDRAb}=xvuw6f^I;jP+gdPvZRpQeF{Ss}qbzJJ z!UUrot+%9QxRTKIJ54l{DfZkh$gm`2CR+7IKeQNPg)!YrlxpuHJIjaEm%AYQFPF+P zhiyP@eO9TlP^M?k)U$MBDce+5I;Vn`om#PWpitlIWuV650?tr$-54iKgeH@O@T1CX5q$69>KA-r0Fr_G5Y8pbabmkg{ z5U3<5v=#hh9uv!g&NHLC3KlIC4*{?dgejeQnPxRf36j)Wqz*NMP<&ZKol^5aY7o0y zlXcxR51X34LPDoz?#N&hQC>Y^-nV*sD7%2pgh_9*Al~4H78BUio>D~4*Jy0l>GnNr zOvg1jLan1S!`wHRBzGB3EAJ8c;zuFNbwg8%-LJ+h3@%2Hn=2tfJ-rM;=6 z7{1E{M`PWYLyT2FzK;&R!O&asHG&#)KOh*vWrY0|`XCIxU*Tao#~C@#gHe{oAC8M* zpTnI|aFW_b;W)l}2Fk3&(K%_kDlrUsFE`Y=xsELtL{s!tAzde{RKhMHHM}T_^umdr z8KHFOApq5^gn4kvg$7;cCx8Ma^ZZnXk%2FJ=9?QNL0cVXAepdB$`Mcc730W)%JJGzNz zVsV5WfhXwL_C|Zx#M&|Y`=9e}zW4H@R06u&8!=FN@4ox)$GPX8?|bjddzqrJ9N1c+ zw&B2Hcq%Y&SV2)MS433@vEl;n>o#BGM&p8!&$t+2~V3S+f+jAkW; zLBYxkqmou$7}Xg*g5-c`AlUYunF?T-w=#LCWs}F&w2*H!(86fKp3sOlY~EJj7>oJK zqE9TUWXVCMJi#)yg3ZL+nG(Th5;OD36&tIE1HdWW^?JL>SLy9Ae4rsB3e+&l(0+y1 z>CCW3zwwsY!w2SU!}$@JiSc)6lH9JDwk^pdvF(~nmEO+cH*wC;eCkbSmbH?UkgnI# zu1ByEHwxK#l#Q2~gE*-XrM^ev#1NL8BKu+_Oe7n`(>D`}o?+~Mk9N(l2E^Gjf|I*+ z)Pw8(yLMj14{UuYf~ya)quib7miV?vc4ECN!1o|Z@bLZKzCg3@2?XsHi|Ol*fl)-z z{^@!91vTWq@6MRDytovnGotGbqZeoI+ADx4PC~0Sg5syJqg0pW*cp-2|w~MN=1s2Li`?7xZrLf)$}A%D+_^Owp=+9>rGV zOm)#5_QC;uWXE6K6}~vB#(qo^VTiIvo2B&-v=A=rR#ql(OJ` zTpIHyv4w1bKYn3pwk9Cv_`ZoJ_)c z0IqIdcAdUj3p3fJSmk{@3LE5&y2Nq`xBHepwp+M~#erQ<5K{A3|77-X@^J+ZUTSnV zu09hKB)R}x96Vo8ZjzJ=6!B9NsccE|#iF@sc%U%AZE7uH`JI;XFcaYX&@%y~s* z-gOJl_T;PG{>?#Z+Jb#ckh?pe;8?tg+QzAUuSYWHSe>$W8i8Qx6YjAj4)VR=u64?> z)h@m?--S#4{u!34Z#Y*6&Kd$!GZ+j#c$9Y*WXc?0Ro}lC-4pi|zv|>d&O#i$TWtlS zxTCqO(T}KV>n{7ACCg>s6Hw!)g=~vqa%5Jpb~DTzsU)sQ~R7f>W&AIo#L z`RLGt-0v0L`mqKj)5lQ#IkgWaJ5erIEFh{ds!GeuP_{h;%Q~(lqb*L_B4wQBx8>#u zYj|JV!m(9<3`bYvCq*Q!bqtCHbOs+o*(kehWBggQjYse(_^)pvif-P=M%LNrA=Y}> ze9NI!&Xqj>EB>l(H711M6bouAm zo--dErA93}z@6Q`r0%xo2WXZ3=GMX=lCv?2M%WG;myhn6w4Q3wVctyx2m9Zn_0*_E zyLo;n+D^^`)V_}#wv2Q2UTfsA*bw*Quxd>EDX;P9-^M66eLb~~(wj!e;ZlQaKX#YVGT{0+=X86=9r#fKaz!XNB1^`J7Fi8^WNpIgEd?49}Zs4l4j>#{vAFCc(e7+8Q$BL!-Y6DaKJgYyziaPTsx0t=5Ayi zFdZ`)6@6eYDZw}kFK$EzIep(A-5Et=>)_;;Jej+Za^mhuu0fgwi805!L<)GVIivl1 zV*cF^1-ZO(S&+2mkVyJ$Lgv8-^*{dtB4~~Z5_>Kf5-}-(rToB3nras`E> z$#sFl$qdSp&J>KYJ-35+nI2KavFx`SwOsOg5zz|PTP|?sj zgZrK+y7O%9Ehof+;_^AUC&q^GGiw-$3hS87nJC)Xy_X;+T?u7pCy2d(L#aZE%3HZh zsnr;XW<;3Iw$ncA8nxz%h(33xnvkcNUr@V!mxGlSb9|yZyw}m6GeRKUgiVC^=r+}x zhRU3RoeIPJx%xh4Ex2*u^qhr0P)k6E>X;%zjz-@d&=a z&|&QKb$j>H0nXk^EvV+2Q5rue1#S<+DKdzp%xSy+weF3lL3uYF)S?|7R+vziXopLg zC{D4G!-UoUw za|HUCx5*Os2C1!dnj3D6P3WwQ7rmVnkZR-s{udF75}f@KARVlYG{29sjv{ByFr>XE zIObsPc@X_a_T=c05RzhW1jzysWd$})3pKaF6Hqn02Y^U})P%VRp99K+uu5)j8|_G( z$X2e=t9nuCFEN@qOJ!}$c7>_7UEpif$1<%Ys0T?S$wWtAxS2lZt+e=1M5W$2X9^?| z>>9QF1P+cGV@se4vLoasQ|F$F{1*2bqOm}tDj)5*p4tcb-}x|kCn9ohNc|jQ>>9mr zqp4RvLFoYZ?v=LEDT=zZc5Uz0G}Z^{JAthOmipoj1{R!_Fd)&XT)aT{iM|lAg`uQf zJf9eMq8>E#%T04z<>rk2;_lHl>vft5Giv`lMT6hy6r;Hn>(28A|J!EJY4sj!UX&ockT<=bmN~CBOd_Dv~9nDUd(JaTgnU!rlLB)~x9`xUfuKI@q{Zrcv zfoWD3QiZ~H*L_or(%?)+tHf4(4GQ!frj_U#Z!101J6G1y|L+T~6dHGT@5Ak`TOT6u1?820|%%R&2j0YekjWi;XlD0I?MeulQ$w+UZ zCD~m-(<7F6_UT`y%};bPn7E+1y;tew}M&O5f2FyJ)D%YVUBA;PB}56cs>ZPytn6ULh)d))J;-RSwY@u-|6t^0X(>qEv;qsQ3a@GP zDau#O%P4;ZYX_m7L^`+YIpO;#RL_Ws(0V%UJtVv)V{)D`xUP^_pqZ4ds84B11Iii< z?bU!W1#1@$|2$<~<9f}k1WB+FU7yBXJNz!)q_@2lK@+rcO6;yAeBdfP={PNom+w}3 zXA%JJx8WznP(o*fh#Z zFXs5r9o^B<$vECA*UQ84GT7ZTcem^S^*c@PWIBUsFK5)90T(}NLrO)&?a|QSbVdb@ z9RYu{m_>~EPzzd-hD4AiNpBJ-_ilTm@=icnQo1o^I*BOXeS5A3oiH*nrB8HgJFu|R zfm`Eg`~uUJ>3Sap=H=>WS&llF>;(gI+vT376^kog4-6bq$vYF%QR-TA@9uMU$<0NB z&$+wz3t(BkfX}pG^8649F?Xr&qfxZ2R}VhdD;Uk*Tj(hpB1mZVY_#Rrypd(RB&v=g z-?n_4%R%MK0J%PRs;w2#y=W^4!n3y$tr6|Y=upidSb8b$&X7jdbZVCydKOnn7DPRa z^loiRH3gM2#~dp*pu2OL1gW*S0;L*^x?Ye$fuBkwk*i~;s3fZ3GcR$Ug@L*sOVd{J z)|Ewik(;tT?Coyj_mGlD$9qBE4vk@?hokk*`%n-~_;xQf`ozj{mDFVH10RV#!u8?k zVN6s>sP={NplE9rw(}m-rUz}X?w}|+>oOzvKv!%GRC*}*#L?9fQM9Cw=E1{p z>0q4jbw?C^`fMYT^pZ?hD@vtRu10okbS>8p*>y|w`=qxh-M59*?^}vIf@UinbC5IQ z9O-EK7!f5%_0O}yaTE6k?VZAPl9F;WLjX3KI2!W_ANyq1oO@cX$7hd`r~lVSm+@~m z|9gtB@sgV4-wph~9{yU7nRFmdNixU?TW?zt?m>&+3+6*x(MU*L7UfnYX|c=y&a$Ja0Lxd%|=G@@F9_mo^<(*0?$fmGg<8yjd{S8R?czGJ_~)z z(x>J*a_1!Vw9vE{Z5T@$w7F}@U~4WfsrK3E>ACMv6ixh7(_m~`rpm+v=6>_ZJo<@yy(Gg z%#%XZAt)ugM;@iDcIlHOh~xHPdhso7sVJNwOF@|RP*6Jj?^xAa=|#qSZDJJ(b6H>Ek?W3oZ?oGD8+ra?AYb8r}@_{ zDCM+*etXib`KE#HttA|MmKKi$OHg)#{0OII@q2b>mU3iY&zt2fJnpBo`vSd|5j0Mp zC#~(tgSGYM4`ij5aNVMk-NEiXcZ+;u^qI{6pNn#LYJo&j&pEk0#&8o*Y1Wc0%wc{N zmkIujTdF=A$!<7iyaz=m+@H`|ilR5w;=XDOA0mw|o1=rOycMNymJEs85duMVB?l=W)T zIxa0Ql6j(!*=#f;j7-!k3}}1-ddW5UM3QOhRkNY+xO9WCk**UWc^5GsPG@9YK5$|tE8WVF8W!HT03dhONZ*#?_!rDL#PSbnfUqIxtbXfa8@Kjfc~ z8usMMCKI>EJX`;k8qNx~<&;RfI14idg1I{lI`B!gM8;C`&_&Ala>A95Lf6Rv4H;m ziMN~P#!j%+L`Si�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 V5Q_paHxP47PCO^RIp^|w4gfKa6r=zE delta 35 tcmV+;0NnqBxdYp{0|)>B&Hw-a+*`2-gv|jvvyIKm1(Tf76tk4m?+Ekm4=Vrw From 5651fc6034da1546d1d2b379063004050a154508 Mon Sep 17 00:00:00 2001 From: Patrick Kitchens Date: Thu, 26 Apr 2018 11:06:39 -0500 Subject: [PATCH 09/13] thanks --- .../Assets/Plugins/Android/Oauthtutorial.meta | 32 + .../Android/Oauthtutorial/AndroidManifest.xml | 17 + .../Oauthtutorial/AndroidManifest.xml.meta | 9 + .../Plugins/Android/Oauthtutorial/libs.meta | 10 + .../Oauthtutorial/libs/oauthtutorial.jar | Bin 0 -> 1264 bytes .../Oauthtutorial/libs/oauthtutorial.jar.meta | 9 + MoCha/Assets/Plugins/Newtonsoft.Json.xml | 9439 +++++++++++++++++ MoCha/Assets/Plugins/Newtonsoft.Json.xml.meta | 9 + 8 files changed, 9525 insertions(+) create mode 100644 MoCha/Assets/Plugins/Android/Oauthtutorial.meta create mode 100644 MoCha/Assets/Plugins/Android/Oauthtutorial/AndroidManifest.xml create mode 100644 MoCha/Assets/Plugins/Android/Oauthtutorial/AndroidManifest.xml.meta create mode 100644 MoCha/Assets/Plugins/Android/Oauthtutorial/libs.meta create mode 100644 MoCha/Assets/Plugins/Android/Oauthtutorial/libs/oauthtutorial.jar create mode 100644 MoCha/Assets/Plugins/Android/Oauthtutorial/libs/oauthtutorial.jar.meta create mode 100644 MoCha/Assets/Plugins/Newtonsoft.Json.xml create mode 100644 MoCha/Assets/Plugins/Newtonsoft.Json.xml.meta diff --git a/MoCha/Assets/Plugins/Android/Oauthtutorial.meta b/MoCha/Assets/Plugins/Android/Oauthtutorial.meta new file mode 100644 index 0000000..875f532 --- /dev/null +++ b/MoCha/Assets/Plugins/Android/Oauthtutorial.meta @@ -0,0 +1,32 @@ +fileFormatVersion: 2 +guid: 29bad9f5cd2fcea41b37212bde01f7ab +folderAsset: yes +timeCreated: 1524756422 +licenseType: Free +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + isPreloaded: 0 + isOverridable: 0 + platformData: + - first: + Android: Android + second: + enabled: 1 + settings: {} + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + userData: + assetBundleName: + assetBundleVariant: diff --git a/MoCha/Assets/Plugins/Android/Oauthtutorial/AndroidManifest.xml b/MoCha/Assets/Plugins/Android/Oauthtutorial/AndroidManifest.xml new file mode 100644 index 0000000..59bf3ee --- /dev/null +++ b/MoCha/Assets/Plugins/Android/Oauthtutorial/AndroidManifest.xml @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/MoCha/Assets/Plugins/Android/Oauthtutorial/AndroidManifest.xml.meta b/MoCha/Assets/Plugins/Android/Oauthtutorial/AndroidManifest.xml.meta new file mode 100644 index 0000000..f72dde3 --- /dev/null +++ b/MoCha/Assets/Plugins/Android/Oauthtutorial/AndroidManifest.xml.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 3451933c2f0cf5048a2d52f76b3de537 +timeCreated: 1524756427 +licenseType: Free +TextScriptImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/MoCha/Assets/Plugins/Android/Oauthtutorial/libs.meta b/MoCha/Assets/Plugins/Android/Oauthtutorial/libs.meta new file mode 100644 index 0000000..06675c4 --- /dev/null +++ b/MoCha/Assets/Plugins/Android/Oauthtutorial/libs.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: 34e95321666f0c64cbf170b85dc31e24 +folderAsset: yes +timeCreated: 1524756422 +licenseType: Free +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/MoCha/Assets/Plugins/Android/Oauthtutorial/libs/oauthtutorial.jar b/MoCha/Assets/Plugins/Android/Oauthtutorial/libs/oauthtutorial.jar new file mode 100644 index 0000000000000000000000000000000000000000..b361859c4081516f98a56849d42351ab69a7a33e GIT binary patch literal 1264 zcmWIWW@Zs#;Nak3XjGf!!+-=t7+4s5T|*poJ^kGDeI5Ng-CTo1^nBg^onl~k{FI3y zz?+?8P3s~N7N8y`AP&H3k|IzxHKkO)Br&&CKQ}))BT?TsF*DCGxg@hJv!qflIVZ8W zxHlxb__CXbt+e&TLKhF0q)Tlg7nwHB71-Khmvp&3nag*hbJypLhHaZCmdl7np7L1D zP`||ZujE_yc1`1&ob(^QKFiBhZ=XEUxYBlW|LW@VJHNlVTl@EY{Cb8v2lS=dB+^`r zH>u>ihuz-(eMji?zVMApiyxeLE_I3Ldd~h_SGnBjv##wsJ-_?Ft&rPaEADqF@(VS!pZxUJ`accPdf%hMu0Bol_>peV``vWU@ec=gt6nl} z?he^6%gUH2r#bEQ<&S@BSI5VQv8;S7I*Fb5kt8TV+b(uiOPw7#7~}e^s-;+Gg>-?P~MBZShuI|5(arYEj_vJzkYb z{n~w9x!neLKFsInuR8p)d+&{9h%s6P?B0hgrn`j%idTp4}@!T$j=G#22r`E}P2LDQ%ZSp`j@z~u&J5?rQ0V6J( z%gbH|Dm~QNvG~^echMc&ryO6^_r9<{Wr>|&obkIWj@KE3&6jR!+A;H})HTyP>Y`O$ zZkGzz&hpp#)4?li0j!h597}o&WmhE^k@5U5!g7YiHxXg~qu*0u#Ee`(EAZe7yenBBw*C zSvN(l==*9{EzG!*k$&+^hMb<9(r0$vwh2oMRm}P>$zKp=pLPD&!!Jiln&)5iYmC!5 zC!h33wP)_4iB?Ba{`$xKV4wNOiG4Gdv1sx$4rYnv7Z(&x`WE~p#OJt7TGQpH0jp2{ zm=JO7w``fN4UtH){xWQbLITfD`!(@y!)$cV;A>hliPZh!~TW2 z_W#*IS>L<&Mf)0N28Nq#psdfxB*K6wMv#jIP%(lEa1|=(rXbq@Dnbyz3& + + + Newtonsoft.Json + + + + + Represents a BSON Oid (object id). + + + + + Initializes a new instance of the class. + + The Oid value. + + + + Gets or sets the value of the Oid. + + The value of the Oid. + + + + Represents a reader that provides fast, non-cached, forward-only access to serialized JSON data. + + + + + Represents a reader that provides fast, non-cached, forward-only access to serialized JSON data. + + + + + Initializes a new instance of the class with the specified . + + + + + Reads the next JSON token from the stream. + + true if the next token was read successfully; false if there are no more tokens to read. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a []. + + A [] or a null reference if the next JSON token is null. This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Skips the children of the current token. + + + + + Sets the current token. + + The new token. + + + + Sets the current token and value. + + The new token. + The value. + + + + Sets the state based on current token type. + + + + + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + + + + + Releases unmanaged and - optionally - managed resources + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Changes the to Closed. + + + + + Gets the current reader state. + + The current reader state. + + + + Gets or sets a value indicating whether the underlying stream or + should be closed when the reader is closed. + + + true to close the underlying stream or when + the reader is closed; otherwise false. The default is true. + + + + + Gets or sets a value indicating whether multiple pieces of JSON content can + be read from a continuous stream without erroring. + + + true to support reading multiple pieces of JSON content; otherwise false. The default is false. + + + + + Gets the quotation mark character used to enclose the value of a string. + + + + + Get or set how time zones are handling when reading JSON. + + + + + Get or set how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON. + + + + + Get or set how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text. + + + + + Get or set how custom date formatted strings are parsed when reading JSON. + + + + + Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a . + + + + + Gets the type of the current JSON token. + + + + + Gets the text value of the current JSON token. + + + + + Gets The Common Language Runtime (CLR) type for the current JSON token. + + + + + Gets the depth of the current token in the JSON document. + + The depth of the current token in the JSON document. + + + + Gets the path of the current JSON token. + + + + + Gets or sets the culture used when reading JSON. Defaults to . + + + + + Specifies the state of the reader. + + + + + The Read method has not been called. + + + + + The end of the file has been reached successfully. + + + + + Reader is at a property. + + + + + Reader is at the start of an object. + + + + + Reader is in an object. + + + + + Reader is at the start of an array. + + + + + Reader is in an array. + + + + + The Close method has been called. + + + + + Reader has just read a value. + + + + + Reader is at the start of a constructor. + + + + + Reader in a constructor. + + + + + An error occurred that prevents the read operation from continuing. + + + + + The end of the file has been reached successfully. + + + + + Initializes a new instance of the class. + + The stream. + + + + Initializes a new instance of the class. + + The reader. + + + + Initializes a new instance of the class. + + The stream. + if set to true the root object will be read as a JSON array. + The used when reading values from BSON. + + + + Initializes a new instance of the class. + + The reader. + if set to true the root object will be read as a JSON array. + The used when reading values from BSON. + + + + Reads the next JSON token from the stream as a []. + + + A [] or a null reference if the next JSON token is null. This method will return null at the end of an array. + + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream. + + + true if the next token was read successfully; false if there are no more tokens to read. + + + + + Changes the to Closed. + + + + + Gets or sets a value indicating whether binary data reading should compatible with incorrect Json.NET 3.5 written binary. + + + true if binary data reading will be compatible with incorrect Json.NET 3.5 written binary; otherwise, false. + + + + + Gets or sets a value indicating whether the root object will be read as a JSON array. + + + true if the root object will be read as a JSON array; otherwise, false. + + + + + Gets or sets the used when reading values from BSON. + + The used when reading values from BSON. + + + + Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data. + + + + + Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data. + + + + + Creates an instance of the JsonWriter class. + + + + + Flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream. + + + + + Closes this stream and the underlying stream. + + + + + Writes the beginning of a JSON object. + + + + + Writes the end of a JSON object. + + + + + Writes the beginning of a JSON array. + + + + + Writes the end of an array. + + + + + Writes the start of a constructor with the given name. + + The name of the constructor. + + + + Writes the end constructor. + + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + A flag to indicate whether the text should be escaped when it is written as a JSON property name. + + + + Writes the end of the current JSON object or array. + + + + + Writes the current token and its children. + + The to read the token from. + + + + Writes the current token. + + The to read the token from. + A flag indicating whether the current token's children should be written. + + + + Writes the token and its value. + + The to write. + + The value to write. + A value is only required for tokens that have an associated value, e.g. the property name for . + A null value can be passed to the method for token's that don't have a value, e.g. . + + + + Writes the token. + + The to write. + + + + Writes the specified end token. + + The end token to write. + + + + Writes indent characters. + + + + + Writes the JSON value delimiter. + + + + + Writes an indent space. + + + + + Writes a null value. + + + + + Writes an undefined value. + + + + + Writes raw JSON without changing the writer's state. + + The raw JSON to write. + + + + Writes raw JSON where a value is expected and updates the writer's state. + + The raw JSON to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a [] value. + + The [] value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + An error will raised if the value cannot be written as a single JSON token. + + The value to write. + + + + Writes out a comment /*...*/ containing the specified text. + + Text to place inside the comment. + + + + Writes out the given white space. + + The string of white space characters. + + + + Sets the state of the JsonWriter, + + The JsonToken being written. + The value being written. + + + + Gets or sets a value indicating whether the underlying stream or + should be closed when the writer is closed. + + + true to close the underlying stream or when + the writer is closed; otherwise false. The default is true. + + + + + Gets the top. + + The top. + + + + Gets the state of the writer. + + + + + Gets the path of the writer. + + + + + Indicates how JSON text output is formatted. + + + + + Get or set how dates are written to JSON text. + + + + + Get or set how time zones are handling when writing JSON text. + + + + + Get or set how strings are escaped when writing JSON text. + + + + + Get or set how special floating point numbers, e.g. , + and , + are written to JSON text. + + + + + Get or set how and values are formatting when writing JSON text. + + + + + Gets or sets the culture used when writing JSON. Defaults to . + + + + + Initializes a new instance of the class. + + The stream. + + + + Initializes a new instance of the class. + + The writer. + + + + Flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream. + + + + + Writes the end. + + The token. + + + + Writes out a comment /*...*/ containing the specified text. + + Text to place inside the comment. + + + + Writes the start of a constructor with the given name. + + The name of the constructor. + + + + Writes raw JSON. + + The raw JSON to write. + + + + Writes raw JSON where a value is expected and updates the writer's state. + + The raw JSON to write. + + + + Writes the beginning of a JSON array. + + + + + Writes the beginning of a JSON object. + + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + + + + Closes this stream and the underlying stream. + + + + + Writes a value. + An error will raised if the value cannot be written as a single JSON token. + + The value to write. + + + + Writes a null value. + + + + + Writes an undefined value. + + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a [] value. + + The [] value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a [] value that represents a BSON object id. + + The Object ID value to write. + + + + Writes a BSON regex. + + The regex pattern. + The regex options. + + + + Gets or sets the used when writing values to BSON. + When set to no conversion will occur. + + The used when writing values to BSON. + + + + Specifies how constructors are used when initializing objects during deserialization by the . + + + + + First attempt to use the public default constructor, then fall back to single paramatized constructor, then the non-public default constructor. + + + + + Json.NET will use a non-public default constructor before falling back to a paramatized constructor. + + + + + Converts a binary value to and from a base 64 string value. + + + + + Converts an object to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + + Gets the of the JSON produced by the JsonConverter. + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + The of the JSON produced by the JsonConverter. + + + + Gets a value indicating whether this can read JSON. + + true if this can read JSON; otherwise, false. + + + + Gets a value indicating whether this can write JSON. + + true if this can write JSON; otherwise, false. + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts a to and from JSON and BSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Create a custom object + + The object type to convert. + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Creates an object which will then be populated by the serializer. + + Type of the object. + The created object. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Gets a value indicating whether this can write JSON. + + + true if this can write JSON; otherwise, false. + + + + + Converts a to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified value type. + + Type of the value. + + true if this instance can convert the specified value type; otherwise, false. + + + + + Converts a to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified value type. + + Type of the value. + + true if this instance can convert the specified value type; otherwise, false. + + + + + Provides a base class for converting a to and from JSON. + + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts a to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts a to and from JSON and BSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts an to and from its name string value. + + + + + Initializes a new instance of the class. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Gets or sets a value indicating whether the written enum text should be camel case. + + true if the written enum text will be camel case; otherwise, false. + + + + Gets or sets a value indicating whether integer values are allowed. + + true if integers are allowed; otherwise, false. + + + + Converts a to and from a string (e.g. "1.2.3.4"). + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing property value of the JSON that is being converted. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Specifies how dates are formatted when writing JSON text. + + + + + Dates are written in the ISO 8601 format, e.g. "2012-03-21T05:40Z". + + + + + Dates are written in the Microsoft JSON format, e.g. "\/Date(1198908717056)\/". + + + + + Specifies how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON text. + + + + + Date formatted strings are not parsed to a date type and are read as strings. + + + + + Date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed to . + + + + + Specifies how to treat the time value when converting between string and . + + + + + Treat as local time. If the object represents a Coordinated Universal Time (UTC), it is converted to the local time. + + + + + Treat as a UTC. If the object represents a local time, it is converted to a UTC. + + + + + Treat as a local time if a is being converted to a string. + If a string is being converted to , convert to a local time if a time zone is specified. + + + + + Time zone information should be preserved when converting. + + + + + Specifies float format handling options when writing special floating point numbers, e.g. , + and with . + + + + + Write special floating point values as strings in JSON, e.g. "NaN", "Infinity", "-Infinity". + + + + + Write special floating point values as symbols in JSON, e.g. NaN, Infinity, -Infinity. + Note that this will produce non-valid JSON. + + + + + Write special floating point values as the property's default value in JSON, e.g. 0.0 for a property, null for a property. + + + + + Specifies how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text. + + + + + Floating point numbers are parsed to . + + + + + Floating point numbers are parsed to . + + + + + Specifies formatting options for the . + + + + + No special formatting is applied. This is the default. + + + + + Causes child objects to be indented according to the and settings. + + + + + Instructs the to use the specified constructor when deserializing that object. + + + + + Instructs the how to serialize the collection. + + + + + Instructs the how to serialize the object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified container Id. + + The container Id. + + + + Gets or sets the id. + + The id. + + + + Gets or sets the title. + + The title. + + + + Gets or sets the description. + + The description. + + + + Gets the collection's items converter. + + The collection's items converter. + + + + The parameter list to use when constructing the JsonConverter described by ItemConverterType. + If null, the default constructor is used. + When non-null, there must be a constructor defined in the JsonConverter that exactly matches the number, + order, and type of these parameters. + + + [JsonContainer(ItemConverterType = typeof(MyContainerConverter), ItemConverterParameters = new object[] { 123, "Four" })] + + + + + Gets or sets a value that indicates whether to preserve object references. + + + true to keep object reference; otherwise, false. The default is false. + + + + + Gets or sets a value that indicates whether to preserve collection's items references. + + + true to keep collection's items object references; otherwise, false. The default is false. + + + + + Gets or sets the reference loop handling used when serializing the collection's items. + + The reference loop handling. + + + + Gets or sets the type name handling used when serializing the collection's items. + + The type name handling. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified container Id. + + The container Id. + + + + The exception thrown when an error occurs during JSON serialization or deserialization. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Instructs the to deserialize properties with no matching class member into the specified collection + and write values during serialization. + + + + + Initializes a new instance of the class. + + + + + Gets or sets a value that indicates whether to write extension data when serializing the object. + + + true to write extension data when serializing the object; otherwise, false. The default is true. + + + + + Gets or sets a value that indicates whether to read extension data when deserializing the object. + + + true to read extension data when deserializing the object; otherwise, false. The default is true. + + + + + Instructs the to always serialize the member, and require the member has a value. + + + + + Specifies the settings used when merging JSON. + + + + + Gets or sets the method used when merging JSON arrays. + + The method used when merging JSON arrays. + + + + Specifies how JSON arrays are merged together. + + + + Concatenate arrays. + + + Union arrays, skipping items that already exist. + + + Replace all array items. + + + Merge array items together, matched by index. + + + + Specifies metadata property handling options for the . + + + + + Read metadata properties located at the start of a JSON object. + + + + + Read metadata properties located anywhere in a JSON object. Note that this setting will impact performance. + + + + + Do not try to read metadata properties. + + + + + Represents a trace writer that writes to the application's instances. + + + + + Represents a trace writer. + + + + + Writes the specified trace level, message and optional exception. + + The at which to write this trace. + The trace message. + The trace exception. This parameter is optional. + + + + Gets the that will be used to filter the trace messages passed to the writer. + For example a filter level of Info will exclude Verbose messages and include Info, + Warning and Error messages. + + The that will be used to filter the trace messages passed to the writer. + + + + Writes the specified trace level, message and optional exception. + + The at which to write this trace. + The trace message. + The trace exception. This parameter is optional. + + + + Gets the that will be used to filter the trace messages passed to the writer. + For example a filter level of Info will exclude Verbose messages and include Info, + Warning and Error messages. + + + The that will be used to filter the trace messages passed to the writer. + + + + + Provides methods to get attributes. + + + + + Returns a collection of all of the attributes, or an empty collection if there are no attributes. + + When true, look up the hierarchy chain for the inherited custom attribute. + A collection of s, or an empty collection. + + + + Returns a collection of attributes, identified by type, or an empty collection if there are no attributes. + + The type of the attributes. + When true, look up the hierarchy chain for the inherited custom attribute. + A collection of s, or an empty collection. + + + + Contract details for a used by the . + + + + + Contract details for a used by the . + + + + + Gets the underlying type for the contract. + + The underlying type for the contract. + + + + Gets or sets the type created during deserialization. + + The type created during deserialization. + + + + Gets or sets whether this type contract is serialized as a reference. + + Whether this type contract is serialized as a reference. + + + + Gets or sets the default for this contract. + + The converter. + + + + Gets or sets all methods called immediately after deserialization of the object. + + The methods called immediately after deserialization of the object. + + + + Gets or sets all methods called during deserialization of the object. + + The methods called during deserialization of the object. + + + + Gets or sets all methods called after serialization of the object graph. + + The methods called after serialization of the object graph. + + + + Gets or sets all methods called before serialization of the object. + + The methods called before serialization of the object. + + + + Gets or sets all method called when an error is thrown during the serialization of the object. + + The methods called when an error is thrown during the serialization of the object. + + + + Gets or sets the method called immediately after deserialization of the object. + + The method called immediately after deserialization of the object. + + + + Gets or sets the method called during deserialization of the object. + + The method called during deserialization of the object. + + + + Gets or sets the method called after serialization of the object graph. + + The method called after serialization of the object graph. + + + + Gets or sets the method called before serialization of the object. + + The method called before serialization of the object. + + + + Gets or sets the method called when an error is thrown during the serialization of the object. + + The method called when an error is thrown during the serialization of the object. + + + + Gets or sets the default creator method used to create the object. + + The default creator method used to create the object. + + + + Gets or sets a value indicating whether the default creator is non public. + + true if the default object creator is non-public; otherwise, false. + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Gets or sets the default collection items . + + The converter. + + + + Gets or sets a value indicating whether the collection items preserve object references. + + true if collection items preserve object references; otherwise, false. + + + + Gets or sets the collection item reference loop handling. + + The reference loop handling. + + + + Gets or sets the collection item type name handling. + + The type name handling. + + + + Represents a trace writer that writes to memory. When the trace message limit is + reached then old trace messages will be removed as new messages are added. + + + + + Initializes a new instance of the class. + + + + + Writes the specified trace level, message and optional exception. + + The at which to write this trace. + The trace message. + The trace exception. This parameter is optional. + + + + Returns an enumeration of the most recent trace messages. + + An enumeration of the most recent trace messages. + + + + Returns a of the most recent trace messages. + + + A of the most recent trace messages. + + + + + Gets the that will be used to filter the trace messages passed to the writer. + For example a filter level of Info will exclude Verbose messages and include Info, + Warning and Error messages. + + + The that will be used to filter the trace messages passed to the writer. + + + + + Provides methods to get attributes from a , , or . + + + + + Initializes a new instance of the class. + + The instance to get attributes for. This parameter should be a , , or . + + + + Returns a collection of all of the attributes, or an empty collection if there are no attributes. + + When true, look up the hierarchy chain for the inherited custom attribute. + A collection of s, or an empty collection. + + + + Returns a collection of attributes, identified by type, or an empty collection if there are no attributes. + + The type of the attributes. + When true, look up the hierarchy chain for the inherited custom attribute. + A collection of s, or an empty collection. + + + + Provides an interface to enable a class to return line and position information. + + + + + Gets a value indicating whether the class can return line information. + + + true if LineNumber and LinePosition can be provided; otherwise, false. + + + + + Gets the current line number. + + The current line number or 0 if no line information is available (for example, HasLineInfo returns false). + + + + Gets the current line position. + + The current line position or 0 if no line information is available (for example, HasLineInfo returns false). + + + + Specifies how strings are escaped when writing JSON text. + + + + + Only control characters (e.g. newline) are escaped. + + + + + All non-ASCII and control characters (e.g. newline) are escaped. + + + + + HTML (<, >, &, ', ") and control characters (e.g. newline) are escaped. + + + + + Provides a set of static (Shared in Visual Basic) methods for + querying objects that implement . + + + + + Returns the input typed as . + + + + + Returns an empty that has the + specified type argument. + + + + + Converts the elements of an to the + specified type. + + + + + Filters the elements of an based on a specified type. + + + + + Generates a sequence of integral numbers within a specified range. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + + + + Generates a sequence that contains one repeated value. + + + + + Filters a sequence of values based on a predicate. + + + + + Filters a sequence of values based on a predicate. + Each element's index is used in the logic of the predicate function. + + + + + Projects each element of a sequence into a new form. + + + + + Projects each element of a sequence into a new form by + incorporating the element's index. + + + + + Projects each element of a sequence to an + and flattens the resulting sequences into one sequence. + + + + + Projects each element of a sequence to an , + and flattens the resulting sequences into one sequence. The + index of each source element is used in the projected form of + that element. + + + + + Projects each element of a sequence to an , + flattens the resulting sequences into one sequence, and invokes + a result selector function on each element therein. + + + + + Projects each element of a sequence to an , + flattens the resulting sequences into one sequence, and invokes + a result selector function on each element therein. The index of + each source element is used in the intermediate projected form + of that element. + + + + + Returns elements from a sequence as long as a specified condition is true. + + + + + Returns elements from a sequence as long as a specified condition is true. + The element's index is used in the logic of the predicate function. + + + + + Base implementation of First operator. + + + + + Returns the first element of a sequence. + + + + + Returns the first element in a sequence that satisfies a specified condition. + + + + + Returns the first element of a sequence, or a default value if + the sequence contains no elements. + + + + + Returns the first element of the sequence that satisfies a + condition or a default value if no such element is found. + + + + + Base implementation of Last operator. + + + + + Returns the last element of a sequence. + + + + + Returns the last element of a sequence that satisfies a + specified condition. + + + + + Returns the last element of a sequence, or a default value if + the sequence contains no elements. + + + + + Returns the last element of a sequence that satisfies a + condition or a default value if no such element is found. + + + + + Base implementation of Single operator. + + + + + Returns the only element of a sequence, and throws an exception + if there is not exactly one element in the sequence. + + + + + Returns the only element of a sequence that satisfies a + specified condition, and throws an exception if more than one + such element exists. + + + + + Returns the only element of a sequence, or a default value if + the sequence is empty; this method throws an exception if there + is more than one element in the sequence. + + + + + Returns the only element of a sequence that satisfies a + specified condition or a default value if no such element + exists; this method throws an exception if more than one element + satisfies the condition. + + + + + Returns the element at a specified index in a sequence. + + + + + Returns the element at a specified index in a sequence or a + default value if the index is out of range. + + + + + Inverts the order of the elements in a sequence. + + + + + Returns a specified number of contiguous elements from the start + of a sequence. + + + + + Bypasses a specified number of elements in a sequence and then + returns the remaining elements. + + + + + Bypasses elements in a sequence as long as a specified condition + is true and then returns the remaining elements. + + + + + Bypasses elements in a sequence as long as a specified condition + is true and then returns the remaining elements. The element's + index is used in the logic of the predicate function. + + + + + Returns the number of elements in a sequence. + + + + + Returns a number that represents how many elements in the + specified sequence satisfy a condition. + + + + + Returns an that represents the total number + of elements in a sequence. + + + + + Returns an that represents how many elements + in a sequence satisfy a condition. + + + + + Concatenates two sequences. + + + + + Creates a from an . + + + + + Creates an array from an . + + + + + Returns distinct elements from a sequence by using the default + equality comparer to compare values. + + + + + Returns distinct elements from a sequence by using a specified + to compare values. + + + + + Creates a from an + according to a specified key + selector function. + + + + + Creates a from an + according to a specified key + selector function and a key comparer. + + + + + Creates a from an + according to specified key + and element selector functions. + + + + + Creates a from an + according to a specified key + selector function, a comparer and an element selector function. + + + + + Groups the elements of a sequence according to a specified key + selector function. + + + + + Groups the elements of a sequence according to a specified key + selector function and compares the keys by using a specified + comparer. + + + + + Groups the elements of a sequence according to a specified key + selector function and projects the elements for each group by + using a specified function. + + + + + Groups the elements of a sequence according to a specified key + selector function and creates a result value from each group and + its key. + + + + + Groups the elements of a sequence according to a key selector + function. The keys are compared by using a comparer and each + group's elements are projected by using a specified function. + + + + + Groups the elements of a sequence according to a specified key + selector function and creates a result value from each group and + its key. The elements of each group are projected by using a + specified function. + + + + + Groups the elements of a sequence according to a specified key + selector function and creates a result value from each group and + its key. The keys are compared by using a specified comparer. + + + + + Groups the elements of a sequence according to a specified key + selector function and creates a result value from each group and + its key. Key values are compared by using a specified comparer, + and the elements of each group are projected by using a + specified function. + + + + + Applies an accumulator function over a sequence. + + + + + Applies an accumulator function over a sequence. The specified + seed value is used as the initial accumulator value. + + + + + Applies an accumulator function over a sequence. The specified + seed value is used as the initial accumulator value, and the + specified function is used to select the result value. + + + + + Produces the set union of two sequences by using the default + equality comparer. + + + + + Produces the set union of two sequences by using a specified + . + + + + + Returns the elements of the specified sequence or the type + parameter's default value in a singleton collection if the + sequence is empty. + + + + + Returns the elements of the specified sequence or the specified + value in a singleton collection if the sequence is empty. + + + + + Determines whether all elements of a sequence satisfy a condition. + + + + + Determines whether a sequence contains any elements. + + + + + Determines whether any element of a sequence satisfies a + condition. + + + + + Determines whether a sequence contains a specified element by + using the default equality comparer. + + + + + Determines whether a sequence contains a specified element by + using a specified . + + + + + Determines whether two sequences are equal by comparing the + elements by using the default equality comparer for their type. + + + + + Determines whether two sequences are equal by comparing their + elements by using a specified . + + + + + Base implementation for Min/Max operator. + + + + + Base implementation for Min/Max operator for nullable types. + + + + + Returns the minimum value in a generic sequence. + + + + + Invokes a transform function on each element of a generic + sequence and returns the minimum resulting value. + + + + + Returns the maximum value in a generic sequence. + + + + + Invokes a transform function on each element of a generic + sequence and returns the maximum resulting value. + + + + + Makes an enumerator seen as enumerable once more. + + + The supplied enumerator must have been started. The first element + returned is the element the enumerator was on when passed in. + DO NOT use this method if the caller must be a generator. It is + mostly safe among aggregate operations. + + + + + Sorts the elements of a sequence in ascending order according to a key. + + + + + Sorts the elements of a sequence in ascending order by using a + specified comparer. + + + + + Sorts the elements of a sequence in descending order according to a key. + + + + + Sorts the elements of a sequence in descending order by using a + specified comparer. + + + + + Performs a subsequent ordering of the elements in a sequence in + ascending order according to a key. + + + + + Performs a subsequent ordering of the elements in a sequence in + ascending order by using a specified comparer. + + + + + Performs a subsequent ordering of the elements in a sequence in + descending order, according to a key. + + + + + Performs a subsequent ordering of the elements in a sequence in + descending order by using a specified comparer. + + + + + Base implementation for Intersect and Except operators. + + + + + Produces the set intersection of two sequences by using the + default equality comparer to compare values. + + + + + Produces the set intersection of two sequences by using the + specified to compare values. + + + + + Produces the set difference of two sequences by using the + default equality comparer to compare values. + + + + + Produces the set difference of two sequences by using the + specified to compare values. + + + + + Creates a from an + according to a specified key + selector function. + + + + + Creates a from an + according to a specified key + selector function and key comparer. + + + + + Creates a from an + according to specified key + selector and element selector functions. + + + + + Creates a from an + according to a specified key + selector function, a comparer, and an element selector function. + + + + + Correlates the elements of two sequences based on matching keys. + The default equality comparer is used to compare keys. + + + + + Correlates the elements of two sequences based on matching keys. + The default equality comparer is used to compare keys. A + specified is used to compare keys. + + + + + Correlates the elements of two sequences based on equality of + keys and groups the results. The default equality comparer is + used to compare keys. + + + + + Correlates the elements of two sequences based on equality of + keys and groups the results. The default equality comparer is + used to compare keys. A specified + is used to compare keys. + + + + + Computes the sum of a sequence of nullable values. + + + + + Computes the sum of a sequence of nullable + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of nullable values. + + + + + Computes the average of a sequence of nullable values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Computes the sum of a sequence of values. + + + + + Computes the sum of a sequence of + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of values. + + + + + Computes the average of a sequence of values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Returns the minimum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the minimum nullable value. + + + + + Returns the maximum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the maximum nullable value. + + + + + Computes the sum of a sequence of nullable values. + + + + + Computes the sum of a sequence of nullable + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of nullable values. + + + + + Computes the average of a sequence of nullable values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Computes the sum of a sequence of values. + + + + + Computes the sum of a sequence of + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of values. + + + + + Computes the average of a sequence of values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Returns the minimum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the minimum nullable value. + + + + + Returns the maximum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the maximum nullable value. + + + + + Computes the sum of a sequence of nullable values. + + + + + Computes the sum of a sequence of nullable + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of nullable values. + + + + + Computes the average of a sequence of nullable values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Computes the sum of a sequence of values. + + + + + Computes the sum of a sequence of + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of values. + + + + + Computes the average of a sequence of values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Returns the minimum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the minimum nullable value. + + + + + Returns the maximum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the maximum nullable value. + + + + + Computes the sum of a sequence of nullable values. + + + + + Computes the sum of a sequence of nullable + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of nullable values. + + + + + Computes the average of a sequence of nullable values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Computes the sum of a sequence of values. + + + + + Computes the sum of a sequence of + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of values. + + + + + Computes the average of a sequence of values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Returns the minimum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the minimum nullable value. + + + + + Returns the maximum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the maximum nullable value. + + + + + Computes the sum of a sequence of nullable values. + + + + + Computes the sum of a sequence of nullable + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of nullable values. + + + + + Computes the average of a sequence of nullable values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Computes the sum of a sequence of values. + + + + + Computes the sum of a sequence of + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of values. + + + + + Computes the average of a sequence of values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Returns the minimum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the minimum nullable value. + + + + + Returns the maximum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the maximum nullable value. + + + + + Represents a collection of objects that have a common key. + + + + + Gets the key of the . + + + + + Defines an indexer, size property, and Boolean search method for + data structures that map keys to + sequences of values. + + + + + Represents a sorted sequence. + + + + + Performs a subsequent ordering on the elements of an + according to a key. + + + + + Represents a collection of keys each mapped to one or more values. + + + + + Determines whether a specified key is in the . + + + + + Applies a transform function to each key and its associated + values and returns the results. + + + + + Returns a generic enumerator that iterates through the . + + + + + Gets the number of key/value collection pairs in the . + + + + + Gets the collection of values indexed by the specified key. + + + + + See issue #11 + for why this method is needed and cannot be expressed as a + lambda at the call site. + + + + + See issue #11 + for why this method is needed and cannot be expressed as a + lambda at the call site. + + + + + This attribute allows us to define extension methods without + requiring .NET Framework 3.5. For more information, see the section, + Extension Methods in .NET Framework 2.0 Apps, + of Basic Instincts: Extension Methods + column in MSDN Magazine, + issue Nov 2007. + + + + + Represents a view of a . + + + + + Initializes a new instance of the class. + + The name. + + + + When overridden in a derived class, returns whether resetting an object changes its value. + + + true if resetting the component changes its value; otherwise, false. + + The component to test for reset capability. + + + + + When overridden in a derived class, gets the current value of the property on a component. + + + The value of a property for a given component. + + The component with the property for which to retrieve the value. + + + + + When overridden in a derived class, resets the value for this property of the component to the default value. + + The component with the property value that is to be reset to the default value. + + + + + When overridden in a derived class, sets the value of the component to a different value. + + The component with the property value that is to be set. + The new value. + + + + + When overridden in a derived class, determines a value indicating whether the value of this property needs to be persisted. + + + true if the property should be persisted; otherwise, false. + + The component with the property to be examined for persistence. + + + + + When overridden in a derived class, gets the type of the component this property is bound to. + + + A that represents the type of component this property is bound to. When the or methods are invoked, the object specified might be an instance of this type. + + + + + When overridden in a derived class, gets a value indicating whether this property is read-only. + + + true if the property is read-only; otherwise, false. + + + + + When overridden in a derived class, gets the type of the property. + + + A that represents the type of the property. + + + + + Gets the hash code for the name of the member. + + + + The hash code for the name of the member. + + + + + Represents a raw JSON string. + + + + + Represents a value in JSON (string, integer, date, etc). + + + + + Represents an abstract JSON token. + + + + + Represents a collection of objects. + + The type of token + + + + Gets the with the specified key. + + + + + + Compares the values of two tokens, including the values of all descendant tokens. + + The first to compare. + The second to compare. + true if the tokens are equal; otherwise false. + + + + Adds the specified content immediately after this token. + + A content object that contains simple content or a collection of content objects to be added after this token. + + + + Adds the specified content immediately before this token. + + A content object that contains simple content or a collection of content objects to be added before this token. + + + + Returns a collection of the ancestor tokens of this token. + + A collection of the ancestor tokens of this token. + + + + Returns a collection of tokens that contain this token, and the ancestors of this token. + + A collection of tokens that contain this token, and the ancestors of this token. + + + + Returns a collection of the sibling tokens after this token, in document order. + + A collection of the sibling tokens after this tokens, in document order. + + + + Returns a collection of the sibling tokens before this token, in document order. + + A collection of the sibling tokens before this token, in document order. + + + + Gets the with the specified key converted to the specified type. + + The type to convert the token to. + The token key. + The converted token value. + + + + Returns a collection of the child tokens of this token, in document order. + + An of containing the child tokens of this , in document order. + + + + Returns a collection of the child tokens of this token, in document order, filtered by the specified type. + + The type to filter the child tokens on. + A containing the child tokens of this , in document order. + + + + Returns a collection of the child values of this token, in document order. + + The type to convert the values to. + A containing the child values of this , in document order. + + + + Removes this token from its parent. + + + + + Replaces this token with the specified token. + + The value. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Returns the indented JSON for this token. + + + The indented JSON for this token. + + + + + Returns the JSON for this token using the given formatting and converters. + + Indicates how the output is formatted. + A collection of which will be used when writing the token. + The JSON for this token using the given formatting and converters. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to []. + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from [] to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Creates an for this token. + + An that can be used to read this token and its descendants. + + + + Creates a from an object. + + The object that will be used to create . + A with the value of the specified object + + + + Creates a from an object using the specified . + + The object that will be used to create . + The that will be used when reading the object. + A with the value of the specified object + + + + Creates the specified .NET type from the . + + The object type that the token will be deserialized to. + The new object created from the JSON value. + + + + Creates the specified .NET type from the . + + The object type that the token will be deserialized to. + The new object created from the JSON value. + + + + Creates the specified .NET type from the using the specified . + + The object type that the token will be deserialized to. + The that will be used when creating the object. + The new object created from the JSON value. + + + + Creates the specified .NET type from the using the specified . + + The object type that the token will be deserialized to. + The that will be used when creating the object. + The new object created from the JSON value. + + + + Creates a from a . + + An positioned at the token to read into this . + + An that contains the token and its descendant tokens + that were read from the reader. The runtime type of the token is determined + by the token type of the first token encountered in the reader. + + + + + Load a from a string that contains JSON. + + A that contains JSON. + A populated from the string that contains JSON. + + + + Creates a from a . + + An positioned at the token to read into this . + + An that contains the token and its descendant tokens + that were read from the reader. The runtime type of the token is determined + by the token type of the first token encountered in the reader. + + + + + Selects a using a JPath expression. Selects the token that matches the object path. + + + A that contains a JPath expression. + + A , or null. + + + + Selects a using a JPath expression. Selects the token that matches the object path. + + + A that contains a JPath expression. + + A flag to indicate whether an error should be thrown if no tokens are found when evaluating part of the expression. + A . + + + + Selects a collection of elements using a JPath expression. + + + A that contains a JPath expression. + + An that contains the selected elements. + + + + Selects a collection of elements using a JPath expression. + + + A that contains a JPath expression. + + A flag to indicate whether an error should be thrown if no tokens are found when evaluating part of the expression. + An that contains the selected elements. + + + + Creates a new instance of the . All child tokens are recursively cloned. + + A new instance of the . + + + + Adds an object to the annotation list of this . + + The annotation to add. + + + + Get the first annotation object of the specified type from this . + + The type of the annotation to retrieve. + The first annotation object that matches the specified type, or null if no annotation is of the specified type. + + + + Gets the first annotation object of the specified type from this . + + The of the annotation to retrieve. + The first annotation object that matches the specified type, or null if no annotation is of the specified type. + + + + Gets a collection of annotations of the specified type for this . + + The type of the annotations to retrieve. + An that contains the annotations for this . + + + + Gets a collection of annotations of the specified type for this . + + The of the annotations to retrieve. + An of that contains the annotations that match the specified type for this . + + + + Removes the annotations of the specified type from this . + + The type of annotations to remove. + + + + Removes the annotations of the specified type from this . + + The of annotations to remove. + + + + Gets a comparer that can compare two tokens for value equality. + + A that can compare two nodes for value equality. + + + + Gets or sets the parent. + + The parent. + + + + Gets the root of this . + + The root of this . + + + + Gets the node type for this . + + The type. + + + + Gets a value indicating whether this token has child tokens. + + + true if this token has child values; otherwise, false. + + + + + Gets the next sibling token of this node. + + The that contains the next sibling token. + + + + Gets the previous sibling token of this node. + + The that contains the previous sibling token. + + + + Gets the path of the JSON token. + + + + + Gets the with the specified key. + + The with the specified key. + + + + Get the first child token of this token. + + A containing the first child token of the . + + + + Get the last child token of this token. + + A containing the last child token of the . + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Creates a comment with the given value. + + The value. + A comment with the given value. + + + + Creates a string with the given value. + + The value. + A string with the given value. + + + + Creates a null value. + + A null value. + + + + Creates a null value. + + A null value. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Indicates whether the current object is equal to another object of the same type. + + + true if the current object is equal to the parameter; otherwise, false. + + An object to compare with this object. + + + + Determines whether the specified is equal to the current . + + The to compare with the current . + + true if the specified is equal to the current ; otherwise, false. + + + The parameter is null. + + + + + Serves as a hash function for a particular type. + + + A hash code for the current . + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object. + + An object to compare with this instance. + + A 32-bit signed integer that indicates the relative order of the objects being compared. The return value has these meanings: + Value + Meaning + Less than zero + This instance is less than . + Zero + This instance is equal to . + Greater than zero + This instance is greater than . + + + is not the same type as this instance. + + + + + Gets a value indicating whether this token has child tokens. + + + true if this token has child values; otherwise, false. + + + + + Gets the node type for this . + + The type. + + + + Gets or sets the underlying token value. + + The underlying token value. + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class. + + The raw json. + + + + Creates an instance of with the content of the reader's current token. + + The reader. + An instance of with the content of the reader's current token. + + + + Indicating whether a property is required. + + + + + The property is not required. The default state. + + + + + The property must be defined in JSON but can be a null value. + + + + + The property must be defined in JSON and cannot be a null value. + + + + + Used to resolve references when serializing and deserializing JSON by the . + + + + + Resolves a reference to its object. + + The serialization context. + The reference to resolve. + The object that + + + + Gets the reference for the sepecified object. + + The serialization context. + The object to get a reference for. + The reference to the object. + + + + Determines whether the specified object is referenced. + + The serialization context. + The object to test for a reference. + + true if the specified object is referenced; otherwise, false. + + + + + Adds a reference to the specified object. + + The serialization context. + The reference. + The object to reference. + + + + Specifies reference handling options for the . + Note that references cannot be preserved when a value is set via a non-default constructor such as types that implement ISerializable. + + + + + + + + Do not preserve references when serializing types. + + + + + Preserve references when serializing into a JSON object structure. + + + + + Preserve references when serializing into a JSON array structure. + + + + + Preserve references when serializing. + + + + + Instructs the how to serialize the collection. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a flag indicating whether the array can contain null items + + A flag indicating whether the array can contain null items. + + + + Initializes a new instance of the class with the specified container Id. + + The container Id. + + + + Gets or sets a value indicating whether null items are allowed in the collection. + + true if null items are allowed in the collection; otherwise, false. + + + + Specifies default value handling options for the . + + + + + + + + + Include members where the member value is the same as the member's default value when serializing objects. + Included members are written to JSON. Has no effect when deserializing. + + + + + Ignore members where the member value is the same as the member's default value when serializing objects + so that is is not written to JSON. + This option will ignore all default values (e.g. null for objects and nullable types; 0 for integers, + decimals and floating point numbers; and false for booleans). The default value ignored can be changed by + placing the on the property. + + + + + Members with a default value but no JSON will be set to their default value when deserializing. + + + + + Ignore members where the member value is the same as the member's default value when serializing objects + and sets members to their default value when deserializing. + + + + + Instructs the to use the specified when serializing the member or class. + + + + + Initializes a new instance of the class. + + Type of the converter. + + + + Initializes a new instance of the class. + + Type of the converter. + Parameter list to use when constructing the JsonConverter. Can be null. + + + + Gets the of the converter. + + The of the converter. + + + + The parameter list to use when constructing the JsonConverter described by ConverterType. + If null, the default constructor is used. + + + + + Instructs the how to serialize the object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified member serialization. + + The member serialization. + + + + Initializes a new instance of the class with the specified container Id. + + The container Id. + + + + Gets or sets the member serialization. + + The member serialization. + + + + Gets or sets a value that indicates whether the object's properties are required. + + + A value indicating whether the object's properties are required. + + + + + Specifies the settings on a object. + + + + + Initializes a new instance of the class. + + + + + Gets or sets how reference loops (e.g. a class referencing itself) is handled. + + Reference loop handling. + + + + Gets or sets how missing members (e.g. JSON contains a property that isn't a member on the object) are handled during deserialization. + + Missing member handling. + + + + Gets or sets how objects are created during deserialization. + + The object creation handling. + + + + Gets or sets how null values are handled during serialization and deserialization. + + Null value handling. + + + + Gets or sets how null default are handled during serialization and deserialization. + + The default value handling. + + + + Gets or sets a collection that will be used during serialization. + + The converters. + + + + Gets or sets how object references are preserved by the serializer. + + The preserve references handling. + + + + Gets or sets how type name writing and reading is handled by the serializer. + + The type name handling. + + + + Gets or sets how metadata properties are used during deserialization. + + The metadata properties handling. + + + + Gets or sets how a type name assembly is written and resolved by the serializer. + + The type name assembly format. + + + + Gets or sets how constructors are used during deserialization. + + The constructor handling. + + + + Gets or sets the contract resolver used by the serializer when + serializing .NET objects to JSON and vice versa. + + The contract resolver. + + + + Gets or sets the equality comparer used by the serializer when comparing references. + + The equality comparer. + + + + Gets or sets the used by the serializer when resolving references. + + The reference resolver. + + + + Gets or sets a function that creates the used by the serializer when resolving references. + + A function that creates the used by the serializer when resolving references. + + + + Gets or sets the used by the serializer when writing trace messages. + + The trace writer. + + + + Gets or sets the used by the serializer when resolving type names. + + The binder. + + + + Gets or sets the error handler called during serialization and deserialization. + + The error handler called during serialization and deserialization. + + + + Gets or sets the used by the serializer when invoking serialization callback methods. + + The context. + + + + Get or set how and values are formatted when writing JSON text, and the expected date format when reading JSON text. + + + + + Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a . + + + + + Indicates how JSON text output is formatted. + + + + + Get or set how dates are written to JSON text. + + + + + Get or set how time zones are handling during serialization and deserialization. + + + + + Get or set how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON. + + + + + Get or set how special floating point numbers, e.g. , + and , + are written as JSON. + + + + + Get or set how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text. + + + + + Get or set how strings are escaped when writing JSON text. + + + + + Gets or sets the culture used when reading JSON. Defaults to . + + + + + Gets a value indicating whether there will be a check for additional content after deserializing an object. + + + true if there will be a check for additional content after deserializing an object; otherwise, false. + + + + + + Represents a reader that provides validation. + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + + + + Initializes a new instance of the class that + validates the content returned from the given . + + The to read from while validating. + + + + Reads the next JSON token from the stream as a . + + A . + + + + Reads the next JSON token from the stream as a []. + + + A [] or a null reference if the next JSON token is null. + + + + + Reads the next JSON token from the stream as a . + + A . + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream. + + + true if the next token was read successfully; false if there are no more tokens to read. + + + + + Sets an event handler for receiving schema validation errors. + + + + + Gets the text value of the current JSON token. + + + + + + Gets the depth of the current token in the JSON document. + + The depth of the current token in the JSON document. + + + + Gets the path of the current JSON token. + + + + + Gets the quotation mark character used to enclose the value of a string. + + + + + + Gets the type of the current JSON token. + + + + + + Gets the Common Language Runtime (CLR) type for the current JSON token. + + + + + + Gets or sets the schema. + + The schema. + + + + Gets the used to construct this . + + The specified in the constructor. + + + + Compares tokens to determine whether they are equal. + + + + + Determines whether the specified objects are equal. + + The first object of type to compare. + The second object of type to compare. + + true if the specified objects are equal; otherwise, false. + + + + + Returns a hash code for the specified object. + + The for which a hash code is to be returned. + A hash code for the specified object. + The type of is a reference type and is null. + + + + Specifies the member serialization options for the . + + + + + All public members are serialized by default. Members can be excluded using or . + This is the default member serialization mode. + + + + + Only members must be marked with or are serialized. + This member serialization mode can also be set by marking the class with . + + + + + All public and private fields are serialized. Members can be excluded using or . + This member serialization mode can also be set by marking the class with + and setting IgnoreSerializableAttribute on to false. + + + + + Specifies how object creation is handled by the . + + + + + Reuse existing objects, create new objects when needed. + + + + + Only reuse existing objects. + + + + + Always create new objects. + + + + + Converts a to and from the ISO 8601 date format (e.g. 2008-04-12T12:53Z). + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Gets or sets the date time styles used when converting a date to and from JSON. + + The date time styles used when converting a date to and from JSON. + + + + Gets or sets the date time format used when converting a date to and from JSON. + + The date time format used when converting a date to and from JSON. + + + + Gets or sets the culture used when converting a date to and from JSON. + + The culture used when converting a date to and from JSON. + + + + Converts a to and from a JavaScript date constructor (e.g. new Date(52231943)). + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing property value of the JSON that is being converted. + The calling serializer. + The object value. + + + + Converts XML to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The calling serializer. + The value. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Checks if the attributeName is a namespace attribute. + + Attribute name to test. + The attribute name prefix if it has one, otherwise an empty string. + True if attribute name is for a namespace attribute, otherwise false. + + + + Determines whether this instance can convert the specified value type. + + Type of the value. + + true if this instance can convert the specified value type; otherwise, false. + + + + + Gets or sets the name of the root element to insert when deserializing to XML if the JSON structure has produces multiple root elements. + + The name of the deserialize root element. + + + + Gets or sets a flag to indicate whether to write the Json.NET array attribute. + This attribute helps preserve arrays when converting the written XML back to JSON. + + true if the array attibute is written to the XML; otherwise, false. + + + + Gets or sets a value indicating whether to write the root JSON object. + + true if the JSON root object is omitted; otherwise, false. + + + + Represents a reader that provides fast, non-cached, forward-only access to JSON text data. + + + + + Initializes a new instance of the class with the specified . + + The TextReader containing the XML data to read. + + + + Reads the next JSON token from the stream. + + + true if the next token was read successfully; false if there are no more tokens to read. + + + + + Reads the next JSON token from the stream as a []. + + + A [] or a null reference if the next JSON token is null. This method will return null at the end of an array. + + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Changes the state to closed. + + + + + Gets a value indicating whether the class can return line information. + + + true if LineNumber and LinePosition can be provided; otherwise, false. + + + + + Gets the current line number. + + + The current line number or 0 if no line information is available (for example, HasLineInfo returns false). + + + + + Gets the current line position. + + + The current line position or 0 if no line information is available (for example, HasLineInfo returns false). + + + + + Instructs the to always serialize the member with the specified name. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified name. + + Name of the property. + + + + Gets or sets the converter used when serializing the property's collection items. + + The collection's items converter. + + + + The parameter list to use when constructing the JsonConverter described by ItemConverterType. + If null, the default constructor is used. + When non-null, there must be a constructor defined in the JsonConverter that exactly matches the number, + order, and type of these parameters. + + + [JsonProperty(ItemConverterType = typeof(MyContainerConverter), ItemConverterParameters = new object[] { 123, "Four" })] + + + + + Gets or sets the null value handling used when serializing this property. + + The null value handling. + + + + Gets or sets the default value handling used when serializing this property. + + The default value handling. + + + + Gets or sets the reference loop handling used when serializing this property. + + The reference loop handling. + + + + Gets or sets the object creation handling used when deserializing this property. + + The object creation handling. + + + + Gets or sets the type name handling used when serializing this property. + + The type name handling. + + + + Gets or sets whether this property's value is serialized as a reference. + + Whether this property's value is serialized as a reference. + + + + Gets or sets the order of serialization and deserialization of a member. + + The numeric order of serialization or deserialization. + + + + Gets or sets a value indicating whether this property is required. + + + A value indicating whether this property is required. + + + + + Gets or sets the name of the property. + + The name of the property. + + + + Gets or sets the the reference loop handling used when serializing the property's collection items. + + The collection's items reference loop handling. + + + + Gets or sets the the type name handling used when serializing the property's collection items. + + The collection's items type name handling. + + + + Gets or sets whether this property's collection items are serialized as a reference. + + Whether this property's collection items are serialized as a reference. + + + + Instructs the not to serialize the public field or public read/write property value. + + + + + Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data. + + + + + Creates an instance of the JsonWriter class using the specified . + + The TextWriter to write to. + + + + Flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream. + + + + + Closes this stream and the underlying stream. + + + + + Writes the beginning of a JSON object. + + + + + Writes the beginning of a JSON array. + + + + + Writes the start of a constructor with the given name. + + The name of the constructor. + + + + Writes the specified end token. + + The end token to write. + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + A flag to indicate whether the text should be escaped when it is written as a JSON property name. + + + + Writes indent characters. + + + + + Writes the JSON value delimiter. + + + + + Writes an indent space. + + + + + Writes a value. + An error will raised if the value cannot be written as a single JSON token. + + The value to write. + + + + Writes a null value. + + + + + Writes an undefined value. + + + + + Writes raw JSON. + + The raw JSON to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a [] value. + + The [] value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes out a comment /*...*/ containing the specified text. + + Text to place inside the comment. + + + + Writes out the given white space. + + The string of white space characters. + + + + Gets or sets how many IndentChars to write for each level in the hierarchy when is set to Formatting.Indented. + + + + + Gets or sets which character to use to quote attribute values. + + + + + Gets or sets which character to use for indenting when is set to Formatting.Indented. + + + + + Gets or sets a value indicating whether object names will be surrounded with quotes. + + + + + The exception thrown when an error occurs while reading JSON text. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Gets the path to the JSON where the error occurred. + + The path to the JSON where the error occurred. + + + + The exception thrown when an error occurs while reading JSON text. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Gets the line number indicating where the error occurred. + + The line number indicating where the error occurred. + + + + Gets the line position indicating where the error occurred. + + The line position indicating where the error occurred. + + + + Gets the path to the JSON where the error occurred. + + The path to the JSON where the error occurred. + + + + Represents a collection of . + + + + + Provides methods for converting between common language runtime types and JSON types. + + + + + + + + Represents JavaScript's boolean value true as a string. This field is read-only. + + + + + Represents JavaScript's boolean value false as a string. This field is read-only. + + + + + Represents JavaScript's null as a string. This field is read-only. + + + + + Represents JavaScript's undefined as a string. This field is read-only. + + + + + Represents JavaScript's positive infinity as a string. This field is read-only. + + + + + Represents JavaScript's negative infinity as a string. This field is read-only. + + + + + Represents JavaScript's NaN as a string. This field is read-only. + + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation using the specified. + + The value to convert. + The format the date will be converted to. + The time zone handling when the date is converted to a string. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + The string delimiter character. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + The string delimiter character. + The string escape handling. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Serializes the specified object to a JSON string. + + The object to serialize. + A JSON string representation of the object. + + + + Serializes the specified object to a JSON string using formatting. + + The object to serialize. + Indicates how the output is formatted. + + A JSON string representation of the object. + + + + + Serializes the specified object to a JSON string using a collection of . + + The object to serialize. + A collection converters used while serializing. + A JSON string representation of the object. + + + + Serializes the specified object to a JSON string using formatting and a collection of . + + The object to serialize. + Indicates how the output is formatted. + A collection converters used while serializing. + A JSON string representation of the object. + + + + Serializes the specified object to a JSON string using . + + The object to serialize. + The used to serialize the object. + If this is null, default serialization settings will be used. + + A JSON string representation of the object. + + + + + Serializes the specified object to a JSON string using a type, formatting and . + + The object to serialize. + The used to serialize the object. + If this is null, default serialization settings will be used. + + The type of the value being serialized. + This parameter is used when is Auto to write out the type name if the type of the value does not match. + Specifing the type is optional. + + + A JSON string representation of the object. + + + + + Serializes the specified object to a JSON string using formatting and . + + The object to serialize. + Indicates how the output is formatted. + The used to serialize the object. + If this is null, default serialization settings will be used. + + A JSON string representation of the object. + + + + + Serializes the specified object to a JSON string using a type, formatting and . + + The object to serialize. + Indicates how the output is formatted. + The used to serialize the object. + If this is null, default serialization settings will be used. + + The type of the value being serialized. + This parameter is used when is Auto to write out the type name if the type of the value does not match. + Specifing the type is optional. + + + A JSON string representation of the object. + + + + + Deserializes the JSON to a .NET object. + + The JSON to deserialize. + The deserialized object from the JSON string. + + + + Deserializes the JSON to a .NET object using . + + The JSON to deserialize. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type. + + The JSON to deserialize. + The of object being deserialized. + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type. + + The type of the object to deserialize to. + The JSON to deserialize. + The deserialized object from the JSON string. + + + + Deserializes the JSON to the given anonymous type. + + + The anonymous type to deserialize to. This can't be specified + traditionally and must be infered from the anonymous type passed + as a parameter. + + The JSON to deserialize. + The anonymous type object. + The deserialized anonymous type from the JSON string. + + + + Deserializes the JSON to the given anonymous type using . + + + The anonymous type to deserialize to. This can't be specified + traditionally and must be infered from the anonymous type passed + as a parameter. + + The JSON to deserialize. + The anonymous type object. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + The deserialized anonymous type from the JSON string. + + + + Deserializes the JSON to the specified .NET type using a collection of . + + The type of the object to deserialize to. + The JSON to deserialize. + Converters to use while deserializing. + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type using . + + The type of the object to deserialize to. + The object to deserialize. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type using a collection of . + + The JSON to deserialize. + The type of the object to deserialize. + Converters to use while deserializing. + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type using . + + The JSON to deserialize. + The type of the object to deserialize to. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + The deserialized object from the JSON string. + + + + Populates the object with values from the JSON string. + + The JSON to populate values from. + The target object to populate values onto. + + + + Populates the object with values from the JSON string using . + + The JSON to populate values from. + The target object to populate values onto. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + + + + Serializes the XML node to a JSON string. + + The node to serialize. + A JSON string of the XmlNode. + + + + Serializes the XML node to a JSON string using formatting. + + The node to serialize. + Indicates how the output is formatted. + A JSON string of the XmlNode. + + + + Serializes the XML node to a JSON string using formatting and omits the root object if is true. + + The node to serialize. + Indicates how the output is formatted. + Omits writing the root object. + A JSON string of the XmlNode. + + + + Deserializes the XmlNode from a JSON string. + + The JSON string. + The deserialized XmlNode + + + + Deserializes the XmlNode from a JSON string nested in a root elment specified by . + + The JSON string. + The name of the root element to append when deserializing. + The deserialized XmlNode + + + + Deserializes the XmlNode from a JSON string nested in a root elment specified by + and writes a .NET array attribute for collections. + + The JSON string. + The name of the root element to append when deserializing. + + A flag to indicate whether to write the Json.NET array attribute. + This attribute helps preserve arrays when converting the written XML back to JSON. + + The deserialized XmlNode + + + + Gets or sets a function that creates default . + Default settings are automatically used by serialization methods on , + and and on . + To serialize without using any default settings create a with + . + + + + + The exception thrown when an error occurs during JSON serialization or deserialization. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Serializes and deserializes objects into and from the JSON format. + The enables you to control how objects are encoded into JSON. + + + + + Initializes a new instance of the class. + + + + + Creates a new instance. + The will not use default settings. + + + A new instance. + The will not use default settings. + + + + + Creates a new instance using the specified . + The will not use default settings. + + The settings to be applied to the . + + A new instance using the specified . + The will not use default settings. + + + + + Creates a new instance. + The will use default settings. + + + A new instance. + The will use default settings. + + + + + Creates a new instance using the specified . + The will use default settings. + + The settings to be applied to the . + + A new instance using the specified . + The will use default settings. + + + + + Populates the JSON values onto the target object. + + The that contains the JSON structure to reader values from. + The target object to populate values onto. + + + + Populates the JSON values onto the target object. + + The that contains the JSON structure to reader values from. + The target object to populate values onto. + + + + Deserializes the JSON structure contained by the specified . + + The that contains the JSON structure to deserialize. + The being deserialized. + + + + Deserializes the JSON structure contained by the specified + into an instance of the specified type. + + The containing the object. + The of object being deserialized. + The instance of being deserialized. + + + + Deserializes the JSON structure contained by the specified + into an instance of the specified type. + + The containing the object. + The type of the object to deserialize. + The instance of being deserialized. + + + + Deserializes the JSON structure contained by the specified + into an instance of the specified type. + + The containing the object. + The of object being deserialized. + The instance of being deserialized. + + + + Serializes the specified and writes the JSON structure + to a Stream using the specified . + + The used to write the JSON structure. + The to serialize. + + + + Serializes the specified and writes the JSON structure + to a Stream using the specified . + + The used to write the JSON structure. + The to serialize. + + The type of the value being serialized. + This parameter is used when is Auto to write out the type name if the type of the value does not match. + Specifing the type is optional. + + + + + Serializes the specified and writes the JSON structure + to a Stream using the specified . + + The used to write the JSON structure. + The to serialize. + + The type of the value being serialized. + This parameter is used when is Auto to write out the type name if the type of the value does not match. + Specifing the type is optional. + + + + + Serializes the specified and writes the JSON structure + to a Stream using the specified . + + The used to write the JSON structure. + The to serialize. + + + + Occurs when the errors during serialization and deserialization. + + + + + Gets or sets the used by the serializer when resolving references. + + + + + Gets or sets the used by the serializer when resolving type names. + + + + + Gets or sets the used by the serializer when writing trace messages. + + The trace writer. + + + + Gets or sets the equality comparer used by the serializer when comparing references. + + The equality comparer. + + + + Gets or sets how type name writing and reading is handled by the serializer. + + + + + Gets or sets how a type name assembly is written and resolved by the serializer. + + The type name assembly format. + + + + Gets or sets how object references are preserved by the serializer. + + + + + Get or set how reference loops (e.g. a class referencing itself) is handled. + + + + + Get or set how missing members (e.g. JSON contains a property that isn't a member on the object) are handled during deserialization. + + + + + Get or set how null values are handled during serialization and deserialization. + + + + + Get or set how null default are handled during serialization and deserialization. + + + + + Gets or sets how objects are created during deserialization. + + The object creation handling. + + + + Gets or sets how constructors are used during deserialization. + + The constructor handling. + + + + Gets or sets how metadata properties are used during deserialization. + + The metadata properties handling. + + + + Gets a collection that will be used during serialization. + + Collection that will be used during serialization. + + + + Gets or sets the contract resolver used by the serializer when + serializing .NET objects to JSON and vice versa. + + + + + Gets or sets the used by the serializer when invoking serialization callback methods. + + The context. + + + + Indicates how JSON text output is formatted. + + + + + Get or set how dates are written to JSON text. + + + + + Get or set how time zones are handling during serialization and deserialization. + + + + + Get or set how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON. + + + + + Get or set how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text. + + + + + Get or set how special floating point numbers, e.g. , + and , + are written as JSON text. + + + + + Get or set how strings are escaped when writing JSON text. + + + + + Get or set how and values are formatted when writing JSON text, and the expected date format when reading JSON text. + + + + + Gets or sets the culture used when reading JSON. Defaults to . + + + + + Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a . + + + + + Gets a value indicating whether there will be a check for additional JSON content after deserializing an object. + + + true if there will be a check for additional JSON content after deserializing an object; otherwise, false. + + + + + Contains the LINQ to JSON extension methods. + + + + + Returns a collection of tokens that contains the ancestors of every token in the source collection. + + The type of the objects in source, constrained to . + An of that contains the source collection. + An of that contains the ancestors of every token in the source collection. + + + + Returns a collection of tokens that contains every token in the source collection, and the ancestors of every token in the source collection. + + The type of the objects in source, constrained to . + An of that contains the source collection. + An of that contains every token in the source collection, the ancestors of every token in the source collection. + + + + Returns a collection of tokens that contains the descendants of every token in the source collection. + + The type of the objects in source, constrained to . + An of that contains the source collection. + An of that contains the descendants of every token in the source collection. + + + + Returns a collection of tokens that contains every token in the source collection, and the descendants of every token in the source collection. + + The type of the objects in source, constrained to . + An of that contains the source collection. + An of that contains every token in the source collection, and the descendants of every token in the source collection. + + + + Returns a collection of child properties of every object in the source collection. + + An of that contains the source collection. + An of that contains the properties of every object in the source collection. + + + + Returns a collection of child values of every object in the source collection with the given key. + + An of that contains the source collection. + The token key. + An of that contains the values of every token in the source collection with the given key. + + + + Returns a collection of child values of every object in the source collection. + + An of that contains the source collection. + An of that contains the values of every token in the source collection. + + + + Returns a collection of converted child values of every object in the source collection with the given key. + + The type to convert the values to. + An of that contains the source collection. + The token key. + An that contains the converted values of every token in the source collection with the given key. + + + + Returns a collection of converted child values of every object in the source collection. + + The type to convert the values to. + An of that contains the source collection. + An that contains the converted values of every token in the source collection. + + + + Converts the value. + + The type to convert the value to. + A cast as a of . + A converted value. + + + + Converts the value. + + The source collection type. + The type to convert the value to. + A cast as a of . + A converted value. + + + + Returns a collection of child tokens of every array in the source collection. + + The source collection type. + An of that contains the source collection. + An of that contains the values of every token in the source collection. + + + + Returns a collection of converted child tokens of every array in the source collection. + + An of that contains the source collection. + The type to convert the values to. + The source collection type. + An that contains the converted values of every token in the source collection. + + + + Returns the input typed as . + + An of that contains the source collection. + The input typed as . + + + + Returns the input typed as . + + The source collection type. + An of that contains the source collection. + The input typed as . + + + + Represents a JSON constructor. + + + + + Represents a token that can contain other tokens. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Returns a collection of the child tokens of this token, in document order. + + + An of containing the child tokens of this , in document order. + + + + + Returns a collection of the child values of this token, in document order. + + The type to convert the values to. + + A containing the child values of this , in document order. + + + + + Returns a collection of the descendant tokens for this token in document order. + + An containing the descendant tokens of the . + + + + Returns a collection of the tokens that contain this token, and all descendant tokens of this token, in document order. + + An containing this token, and all the descendant tokens of the . + + + + Adds the specified content as children of this . + + The content to be added. + + + + Adds the specified content as the first children of this . + + The content to be added. + + + + Creates an that can be used to add tokens to the . + + An that is ready to have content written to it. + + + + Replaces the children nodes of this token with the specified content. + + The content. + + + + Removes the child nodes from this token. + + + + + Merge the specified content into this . + + The content to be merged. + + + + Merge the specified content into this using . + + The content to be merged. + The used to merge the content. + + + + Occurs when the list changes or an item in the list changes. + + + + + Occurs before an item is added to the collection. + + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Gets a value indicating whether this token has child tokens. + + + true if this token has child values; otherwise, false. + + + + + Get the first child token of this token. + + + A containing the first child token of the . + + + + + Get the last child token of this token. + + + A containing the last child token of the . + + + + + Gets the count of child JSON tokens. + + The count of child JSON tokens + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class with the specified name and content. + + The constructor name. + The contents of the constructor. + + + + Initializes a new instance of the class with the specified name and content. + + The constructor name. + The contents of the constructor. + + + + Initializes a new instance of the class with the specified name. + + The constructor name. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Loads an from a . + + A that will be read for the content of the . + A that contains the JSON that was read from the specified . + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Gets or sets the name of this constructor. + + The constructor name. + + + + Gets the node type for this . + + The type. + + + + Gets the with the specified key. + + The with the specified key. + + + + Represents a collection of objects. + + The type of token + + + + An empty collection of objects. + + + + + Initializes a new instance of the struct. + + The enumerable. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Gets the with the specified key. + + + + + + Represents a JSON object. + + + + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class with the specified content. + + The contents of the object. + + + + Initializes a new instance of the class with the specified content. + + The contents of the object. + + + + Gets an of this object's properties. + + An of this object's properties. + + + + Gets a the specified name. + + The property name. + A with the specified name or null. + + + + Gets an of this object's property values. + + An of this object's property values. + + + + Loads an from a . + + A that will be read for the content of the . + A that contains the JSON that was read from the specified . + + + + Load a from a string that contains JSON. + + A that contains JSON. + A populated from the string that contains JSON. + + + + + + + Creates a from an object. + + The object that will be used to create . + A with the values of the specified object + + + + Creates a from an object. + + The object that will be used to create . + The that will be used to read the object. + A with the values of the specified object + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Gets the with the specified property name. + + Name of the property. + The with the specified property name. + + + + Gets the with the specified property name. + The exact property name will be searched for first and if no matching property is found then + the will be used to match a property. + + Name of the property. + One of the enumeration values that specifies how the strings will be compared. + The with the specified property name. + + + + Tries to get the with the specified property name. + The exact property name will be searched for first and if no matching property is found then + the will be used to match a property. + + Name of the property. + The value. + One of the enumeration values that specifies how the strings will be compared. + true if a value was successfully retrieved; otherwise, false. + + + + Adds the specified property name. + + Name of the property. + The value. + + + + Removes the property with the specified name. + + Name of the property. + true if item was successfully removed; otherwise, false. + + + + Tries the get value. + + Name of the property. + The value. + true if a value was successfully retrieved; otherwise, false. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Raises the event with the provided arguments. + + Name of the property. + + + + Returns the properties for this instance of a component. + + + A that represents the properties for this component instance. + + + + + Returns the properties for this instance of a component using the attribute array as a filter. + + An array of type that is used as a filter. + + A that represents the filtered properties for this component instance. + + + + + Returns a collection of custom attributes for this instance of a component. + + + An containing the attributes for this object. + + + + + Returns the class name of this instance of a component. + + + The class name of the object, or null if the class does not have a name. + + + + + Returns the name of this instance of a component. + + + The name of the object, or null if the object does not have a name. + + + + + Returns a type converter for this instance of a component. + + + A that is the converter for this object, or null if there is no for this object. + + + + + Returns the default event for this instance of a component. + + + An that represents the default event for this object, or null if this object does not have events. + + + + + Returns the default property for this instance of a component. + + + A that represents the default property for this object, or null if this object does not have properties. + + + + + Returns an editor of the specified type for this instance of a component. + + A that represents the editor for this object. + + An of the specified type that is the editor for this object, or null if the editor cannot be found. + + + + + Returns the events for this instance of a component using the specified attribute array as a filter. + + An array of type that is used as a filter. + + An that represents the filtered events for this component instance. + + + + + Returns the events for this instance of a component. + + + An that represents the events for this component instance. + + + + + Returns an object that contains the property described by the specified property descriptor. + + A that represents the property whose owner is to be found. + + An that represents the owner of the specified property. + + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Occurs when a property value changes. + + + + + Gets the node type for this . + + The type. + + + + Gets the with the specified key. + + The with the specified key. + + + + Gets or sets the with the specified property name. + + + + + + Represents a JSON array. + + + + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class with the specified content. + + The contents of the array. + + + + Initializes a new instance of the class with the specified content. + + The contents of the array. + + + + Loads an from a . + + A that will be read for the content of the . + A that contains the JSON that was read from the specified . + + + + Load a from a string that contains JSON. + + A that contains JSON. + A populated from the string that contains JSON. + + + + + + + Creates a from an object. + + The object that will be used to create . + A with the values of the specified object + + + + Creates a from an object. + + The object that will be used to create . + The that will be used to read the object. + A with the values of the specified object + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Determines the index of a specific item in the . + + The object to locate in the . + + The index of if found in the list; otherwise, -1. + + + + + Inserts an item to the at the specified index. + + The zero-based index at which should be inserted. + The object to insert into the . + + is not a valid index in the . + The is read-only. + + + + Removes the item at the specified index. + + The zero-based index of the item to remove. + + is not a valid index in the . + The is read-only. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Adds an item to the . + + The object to add to the . + The is read-only. + + + + Removes all items from the . + + The is read-only. + + + + Determines whether the contains a specific value. + + The object to locate in the . + + true if is found in the ; otherwise, false. + + + + + Copies to. + + The array. + Index of the array. + + + + Removes the first occurrence of a specific object from the . + + The object to remove from the . + + true if was successfully removed from the ; otherwise, false. This method also returns false if is not found in the original . + + The is read-only. + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Gets the node type for this . + + The type. + + + + Gets the with the specified key. + + The with the specified key. + + + + Gets or sets the at the specified index. + + + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + Represents a reader that provides fast, non-cached, forward-only access to serialized JSON data. + + + + + Initializes a new instance of the class. + + The token to read from. + + + + Reads the next JSON token from the stream as a []. + + + A [] or a null reference if the next JSON token is null. This method will return null at the end of an array. + + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the stream. + + + true if the next token was read successfully; false if there are no more tokens to read. + + + + + Gets the at the reader's current position. + + + + + Gets the path of the current JSON token. + + + + + Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data. + + + + + Initializes a new instance of the class writing to the given . + + The container being written to. + + + + Initializes a new instance of the class. + + + + + Flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream. + + + + + Closes this stream and the underlying stream. + + + + + Writes the beginning of a JSON object. + + + + + Writes the beginning of a JSON array. + + + + + Writes the start of a constructor with the given name. + + The name of the constructor. + + + + Writes the end. + + The token. + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + + + + Writes a value. + An error will raised if the value cannot be written as a single JSON token. + + The value to write. + + + + Writes a null value. + + + + + Writes an undefined value. + + + + + Writes raw JSON. + + The raw JSON to write. + + + + Writes out a comment /*...*/ containing the specified text. + + Text to place inside the comment. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a [] value. + + The [] value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Gets the at the writer's current position. + + + + + Gets the token being writen. + + The token being writen. + + + + Represents a JSON property. + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class. + + The property name. + The property content. + + + + Initializes a new instance of the class. + + The property name. + The property content. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Loads an from a . + + A that will be read for the content of the . + A that contains the JSON that was read from the specified . + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Gets the property name. + + The property name. + + + + Gets or sets the property value. + + The property value. + + + + Gets the node type for this . + + The type. + + + + Specifies the type of token. + + + + + No token type has been set. + + + + + A JSON object. + + + + + A JSON array. + + + + + A JSON constructor. + + + + + A JSON object property. + + + + + A comment. + + + + + An integer value. + + + + + A float value. + + + + + A string value. + + + + + A boolean value. + + + + + A null value. + + + + + An undefined value. + + + + + A date value. + + + + + A raw JSON value. + + + + + A collection of bytes value. + + + + + A Guid value. + + + + + A Uri value. + + + + + A TimeSpan value. + + + + + + Contains the JSON schema extension methods. + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + + + + + Determines whether the is valid. + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + The source to test. + The schema to test with. + + true if the specified is valid; otherwise, false. + + + + + + Determines whether the is valid. + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + The source to test. + The schema to test with. + When this method returns, contains any error messages generated while validating. + + true if the specified is valid; otherwise, false. + + + + + + Validates the specified . + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + The source to test. + The schema to test with. + + + + + Validates the specified . + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + The source to test. + The schema to test with. + The validation event handler. + + + + + Returns detailed information about the schema exception. + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Gets the line number indicating where the error occurred. + + The line number indicating where the error occurred. + + + + Gets the line position indicating where the error occurred. + + The line position indicating where the error occurred. + + + + Gets the path to the JSON where the error occurred. + + The path to the JSON where the error occurred. + + + + + Resolves from an id. + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + + + + Initializes a new instance of the class. + + + + + Gets a for the specified reference. + + The id. + A for the specified reference. + + + + Gets or sets the loaded schemas. + + The loaded schemas. + + + + + Specifies undefined schema Id handling options for the . + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + + + + Do not infer a schema Id. + + + + + Use the .NET type name as the schema Id. + + + + + Use the assembly qualified .NET type name as the schema Id. + + + + + + Returns detailed information related to the . + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + + + + Gets the associated with the validation error. + + The JsonSchemaException associated with the validation error. + + + + Gets the path of the JSON location where the validation error occurred. + + The path of the JSON location where the validation error occurred. + + + + Gets the text description corresponding to the validation error. + + The text description. + + + + + Represents the callback method that will handle JSON schema validation events and the . + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + + + + Resolves member mappings for a type, camel casing property names. + + + + + Used by to resolves a for a given . + + + + + Used by to resolves a for a given . + + + + + + + + + Resolves the contract for a given type. + + The type to resolve a contract for. + The contract for a given type. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + + If set to true the will use a cached shared with other resolvers of the same type. + Sharing the cache will significantly improve performance with multiple resolver instances because expensive reflection will only + happen once. This setting can cause unexpected behavior if different instances of the resolver are suppose to produce different + results. When set to false it is highly recommended to reuse instances with the . + + + + + Resolves the contract for a given type. + + The type to resolve a contract for. + The contract for a given type. + + + + Gets the serializable members for the type. + + The type to get serializable members for. + The serializable members for the type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates the constructor parameters. + + The constructor to create properties for. + The type's member properties. + Properties for the given . + + + + Creates a for the given . + + The matching member property. + The constructor parameter. + A created for the given . + + + + Resolves the default for the contract. + + Type of the object. + The contract's default . + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Determines which contract type is created for the given type. + + Type of the object. + A for the given type. + + + + Creates properties for the given . + + The type to create properties for. + /// The member serialization mode for the type. + Properties for the given . + + + + Creates the used by the serializer to get and set values from a member. + + The member. + The used by the serializer to get and set values from a member. + + + + Creates a for the given . + + The member's parent . + The member to create a for. + A created for the given . + + + + Resolves the name of the property. + + Name of the property. + Resolved name of the property. + + + + Resolves the key of the dictionary. By default is used to resolve dictionary keys. + + Key of the dictionary. + Resolved key of the dictionary. + + + + Gets the resolved name of the property. + + Name of the property. + Name of the property. + + + + Gets a value indicating whether members are being get and set using dynamic code generation. + This value is determined by the runtime permissions available. + + + true if using dynamic code generation; otherwise, false. + + + + + Gets or sets the default members search flags. + + The default members search flags. + + + + Gets or sets a value indicating whether compiler generated members should be serialized. + + + true if serialized compiler generated members; otherwise, false. + + + + + Gets or sets a value indicating whether to ignore the interface when serializing and deserializing types. + + + true if the interface will be ignored when serializing and deserializing types; otherwise, false. + + + + + Gets or sets a value indicating whether to ignore the attribute when serializing and deserializing types. + + + true if the attribute will be ignored when serializing and deserializing types; otherwise, false. + + + + + Initializes a new instance of the class. + + + + + Resolves the name of the property. + + Name of the property. + The property name camel cased. + + + + The default serialization binder used when resolving and loading classes from type names. + + + + + When overridden in a derived class, controls the binding of a serialized object to a type. + + Specifies the name of the serialized object. + Specifies the name of the serialized object. + + The type of the object the formatter creates a new instance of. + + + + + Get and set values for a using dynamic methods. + + + + + Provides methods to get and set values. + + + + + Sets the value. + + The target to set the value on. + The value to set on the target. + + + + Gets the value. + + The target to get the value from. + The value. + + + + Initializes a new instance of the class. + + The member info. + + + + Sets the value. + + The target to set the value on. + The value to set on the target. + + + + Gets the value. + + The target to get the value from. + The value. + + + + Provides information surrounding an error. + + + + + Gets the error. + + The error. + + + + Gets the original object that caused the error. + + The original object that caused the error. + + + + Gets the member that caused the error. + + The member that caused the error. + + + + Gets the path of the JSON location where the error occurred. + + The path of the JSON location where the error occurred. + + + + Gets or sets a value indicating whether this is handled. + + true if handled; otherwise, false. + + + + Provides data for the Error event. + + + + + Initializes a new instance of the class. + + The current object. + The error context. + + + + Gets the current object the error event is being raised against. + + The current object the error event is being raised against. + + + + Gets the error context. + + The error context. + + + + Contract details for a used by the . + + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Gets the of the collection items. + + The of the collection items. + + + + Gets a value indicating whether the collection type is a multidimensional array. + + true if the collection type is a multidimensional array; otherwise, false. + + + + Handles serialization callback events. + + The object that raised the callback event. + The streaming context. + + + + Handles serialization error callback events. + + The object that raised the callback event. + The streaming context. + The error context. + + + + Sets extension data for an object during deserialization. + + The object to set extension data on. + The extension data key. + The extension data value. + + + + Gets extension data for an object during serialization. + + The object to set extension data on. + + + + Contract details for a used by the . + + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Gets or sets the property name resolver. + + The property name resolver. + + + + Gets or sets the dictionary key resolver. + + The dictionary key resolver. + + + + Gets the of the dictionary keys. + + The of the dictionary keys. + + + + Gets the of the dictionary values. + + The of the dictionary values. + + + + Contract details for a used by the . + + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Gets or sets the ISerializable object constructor. + + The ISerializable object constructor. + + + + Contract details for a used by the . + + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Contract details for a used by the . + + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Maps a JSON property to a .NET member or constructor parameter. + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Gets or sets the name of the property. + + The name of the property. + + + + Gets or sets the type that declared this property. + + The type that declared this property. + + + + Gets or sets the order of serialization and deserialization of a member. + + The numeric order of serialization or deserialization. + + + + Gets or sets the name of the underlying member or parameter. + + The name of the underlying member or parameter. + + + + Gets the that will get and set the during serialization. + + The that will get and set the during serialization. + + + + Gets or sets the for this property. + + The for this property. + + + + Gets or sets the type of the property. + + The type of the property. + + + + Gets or sets the for the property. + If set this converter takes presidence over the contract converter for the property type. + + The converter. + + + + Gets or sets the member converter. + + The member converter. + + + + Gets or sets a value indicating whether this is ignored. + + true if ignored; otherwise, false. + + + + Gets or sets a value indicating whether this is readable. + + true if readable; otherwise, false. + + + + Gets or sets a value indicating whether this is writable. + + true if writable; otherwise, false. + + + + Gets or sets a value indicating whether this has a member attribute. + + true if has a member attribute; otherwise, false. + + + + Gets the default value. + + The default value. + + + + Gets or sets a value indicating whether this is required. + + A value indicating whether this is required. + + + + Gets or sets a value indicating whether this property preserves object references. + + + true if this instance is reference; otherwise, false. + + + + + Gets or sets the property null value handling. + + The null value handling. + + + + Gets or sets the property default value handling. + + The default value handling. + + + + Gets or sets the property reference loop handling. + + The reference loop handling. + + + + Gets or sets the property object creation handling. + + The object creation handling. + + + + Gets or sets or sets the type name handling. + + The type name handling. + + + + Gets or sets a predicate used to determine whether the property should be serialize. + + A predicate used to determine whether the property should be serialize. + + + + Gets or sets a predicate used to determine whether the property should be serialized. + + A predicate used to determine whether the property should be serialized. + + + + Gets or sets an action used to set whether the property has been deserialized. + + An action used to set whether the property has been deserialized. + + + + Gets or sets the converter used when serializing the property's collection items. + + The collection's items converter. + + + + Gets or sets whether this property's collection items are serialized as a reference. + + Whether this property's collection items are serialized as a reference. + + + + Gets or sets the the type name handling used when serializing the property's collection items. + + The collection's items type name handling. + + + + Gets or sets the the reference loop handling used when serializing the property's collection items. + + The collection's items reference loop handling. + + + + A collection of objects. + + + + + Initializes a new instance of the class. + + The type. + + + + When implemented in a derived class, extracts the key from the specified element. + + The element from which to extract the key. + The key for the specified element. + + + + Adds a object. + + The property to add to the collection. + + + + Gets the closest matching object. + First attempts to get an exact case match of propertyName and then + a case insensitive match. + + Name of the property. + A matching property if found. + + + + Gets a property by property name. + + The name of the property to get. + Type property name string comparison. + A matching property if found. + + + + Specifies missing member handling options for the . + + + + + Ignore a missing member and do not attempt to deserialize it. + + + + + Throw a when a missing member is encountered during deserialization. + + + + + Specifies null value handling options for the . + + + + + + + + + Include null values when serializing and deserializing objects. + + + + + Ignore null values when serializing and deserializing objects. + + + + + Specifies reference loop handling options for the . + + + + + Throw a when a loop is encountered. + + + + + Ignore loop references and do not serialize. + + + + + Serialize loop references. + + + + + + An in-memory representation of a JSON Schema. + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + + + + Initializes a new instance of the class. + + + + + Reads a from the specified . + + The containing the JSON Schema to read. + The object representing the JSON Schema. + + + + Reads a from the specified . + + The containing the JSON Schema to read. + The to use when resolving schema references. + The object representing the JSON Schema. + + + + Load a from a string that contains schema JSON. + + A that contains JSON. + A populated from the string that contains JSON. + + + + Parses the specified json. + + The json. + The resolver. + A populated from the string that contains JSON. + + + + Writes this schema to a . + + A into which this method will write. + + + + Writes this schema to a using the specified . + + A into which this method will write. + The resolver used. + + + + Returns a that represents the current . + + + A that represents the current . + + + + + Gets or sets the id. + + + + + Gets or sets the title. + + + + + Gets or sets whether the object is required. + + + + + Gets or sets whether the object is read only. + + + + + Gets or sets whether the object is visible to users. + + + + + Gets or sets whether the object is transient. + + + + + Gets or sets the description of the object. + + + + + Gets or sets the types of values allowed by the object. + + The type. + + + + Gets or sets the pattern. + + The pattern. + + + + Gets or sets the minimum length. + + The minimum length. + + + + Gets or sets the maximum length. + + The maximum length. + + + + Gets or sets a number that the value should be divisble by. + + A number that the value should be divisble by. + + + + Gets or sets the minimum. + + The minimum. + + + + Gets or sets the maximum. + + The maximum. + + + + Gets or sets a flag indicating whether the value can not equal the number defined by the "minimum" attribute. + + A flag indicating whether the value can not equal the number defined by the "minimum" attribute. + + + + Gets or sets a flag indicating whether the value can not equal the number defined by the "maximum" attribute. + + A flag indicating whether the value can not equal the number defined by the "maximum" attribute. + + + + Gets or sets the minimum number of items. + + The minimum number of items. + + + + Gets or sets the maximum number of items. + + The maximum number of items. + + + + Gets or sets the of items. + + The of items. + + + + Gets or sets a value indicating whether items in an array are validated using the instance at their array position from . + + + true if items are validated using their array position; otherwise, false. + + + + + Gets or sets the of additional items. + + The of additional items. + + + + Gets or sets a value indicating whether additional items are allowed. + + + true if additional items are allowed; otherwise, false. + + + + + Gets or sets whether the array items must be unique. + + + + + Gets or sets the of properties. + + The of properties. + + + + Gets or sets the of additional properties. + + The of additional properties. + + + + Gets or sets the pattern properties. + + The pattern properties. + + + + Gets or sets a value indicating whether additional properties are allowed. + + + true if additional properties are allowed; otherwise, false. + + + + + Gets or sets the required property if this property is present. + + The required property if this property is present. + + + + Gets or sets the a collection of valid enum values allowed. + + A collection of valid enum values allowed. + + + + Gets or sets disallowed types. + + The disallow types. + + + + Gets or sets the default value. + + The default value. + + + + Gets or sets the collection of that this schema extends. + + The collection of that this schema extends. + + + + Gets or sets the format. + + The format. + + + + + Generates a from a specified . + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + + + + Generate a from the specified type. + + The type to generate a from. + A generated from the specified type. + + + + Generate a from the specified type. + + The type to generate a from. + The used to resolve schema references. + A generated from the specified type. + + + + Generate a from the specified type. + + The type to generate a from. + Specify whether the generated root will be nullable. + A generated from the specified type. + + + + Generate a from the specified type. + + The type to generate a from. + The used to resolve schema references. + Specify whether the generated root will be nullable. + A generated from the specified type. + + + + Gets or sets how undefined schemas are handled by the serializer. + + + + + Gets or sets the contract resolver. + + The contract resolver. + + + + + The value types allowed by the . + + + JSON Schema validation has been moved to its own package. See http://www.newtonsoft.com/jsonschema for more details. + + + + + + No type specified. + + + + + String type. + + + + + Float type. + + + + + Integer type. + + + + + Boolean type. + + + + + Object type. + + + + + Array type. + + + + + Null type. + + + + + Any type. + + + + + Contract details for a used by the . + + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Gets or sets the object member serialization. + + The member object serialization. + + + + Gets or sets a value that indicates whether the object's properties are required. + + + A value indicating whether the object's properties are required. + + + + + Gets the object's properties. + + The object's properties. + + + + Gets the constructor parameters required for any non-default constructor + + + + + Gets a collection of instances that define the parameters used with . + + + + + Gets or sets the override constructor used to create the object. + This is set when a constructor is marked up using the + JsonConstructor attribute. + + The override constructor. + + + + Gets or sets the parametrized constructor used to create the object. + + The parametrized constructor. + + + + Gets or sets the function used to create the object. When set this function will override . + This function is called with a collection of arguments which are defined by the collection. + + The function used to create the object. + + + + Gets or sets the extension data setter. + + + + + Gets or sets the extension data getter. + + + + + Contract details for a used by the . + + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Lookup and create an instance of the JsonConverter type described by the argument. + + The JsonConverter type to create. + Optional arguments to pass to an initializing constructor of the JsonConverter. + If null, the default constructor is used. + + + + Create a factory function that can be used to create instances of a JsonConverter described by the + argument type. The returned function can then be used to either invoke the converter's default ctor, or any + parameterized constructors by way of an object array. + + + + + Represents a method that constructs an object. + + The object type to create. + + + + When applied to a method, specifies that the method is called when an error occurs serializing an object. + + + + + Get and set values for a using reflection. + + + + + Initializes a new instance of the class. + + The member info. + + + + Sets the value. + + The target to set the value on. + The value to set on the target. + + + + Gets the value. + + The target to get the value from. + The value. + + + + Specifies type name handling options for the . + + + + + Do not include the .NET type name when serializing types. + + + + + Include the .NET type name when serializing into a JSON object structure. + + + + + Include the .NET type name when serializing into a JSON array structure. + + + + + Always include the .NET type name when serializing. + + + + + Include the .NET type name when the type of the object being serialized is not the same as its declared type. + + + + + Converts the value to the specified type. If the value is unable to be converted, the + value is checked whether it assignable to the specified type. + + The value to convert. + The culture to use when converting. + The type to convert or cast the value to. + + The converted type. If conversion was unsuccessful, the initial value + is returned if assignable to the target type. + + + + + Gets a dictionary of the names and values of an Enum type. + + + + + + Gets a dictionary of the names and values of an Enum type. + + The enum type to get names and values for. + + + + + Specifies the type of JSON token. + + + + + This is returned by the if a method has not been called. + + + + + An object start token. + + + + + An array start token. + + + + + A constructor start token. + + + + + An object property name. + + + + + A comment. + + + + + Raw JSON. + + + + + An integer. + + + + + A float. + + + + + A string. + + + + + A boolean. + + + + + A null token. + + + + + An undefined token. + + + + + An object end token. + + + + + An array end token. + + + + + A constructor end token. + + + + + A Date. + + + + + Byte data. + + + + + Builds a string. Unlike StringBuilder this class lets you reuse it's internal buffer. + + + + + Determines whether the collection is null or empty. + + The collection. + + true if the collection is null or empty; otherwise, false. + + + + + Adds the elements of the specified collection to the specified generic IList. + + The list to add to. + The collection of elements to add. + + + + Returns the index of the first occurrence in a sequence by using a specified IEqualityComparer{TSource}. + + The type of the elements of source. + A sequence in which to locate a value. + The object to locate in the sequence + An equality comparer to compare values. + The zero-based index of the first occurrence of value within the entire sequence, if found; otherwise, –1. + + + + Gets the type of the typed collection's items. + + The type. + The type of the typed collection's items. + + + + Gets the member's underlying type. + + The member. + The underlying type of the member. + + + + Determines whether the member is an indexed property. + + The member. + + true if the member is an indexed property; otherwise, false. + + + + + Determines whether the property is an indexed property. + + The property. + + true if the property is an indexed property; otherwise, false. + + + + + Gets the member's value on the object. + + The member. + The target object. + The member's value on the object. + + + + Sets the member's value on the target object. + + The member. + The target. + The value. + + + + Determines whether the specified MemberInfo can be read. + + The MemberInfo to determine whether can be read. + /// if set to true then allow the member to be gotten non-publicly. + + true if the specified MemberInfo can be read; otherwise, false. + + + + + Determines whether the specified MemberInfo can be set. + + The MemberInfo to determine whether can be set. + if set to true then allow the member to be set non-publicly. + if set to true then allow the member to be set if read-only. + + true if the specified MemberInfo can be set; otherwise, false. + + + + + Determines whether the string is all white space. Empty string will return false. + + The string to test whether it is all white space. + + true if the string is all white space; otherwise, false. + + + + + Nulls an empty string. + + The string. + Null if the string was null, otherwise the string unchanged. + + + + Specifies the state of the . + + + + + An exception has been thrown, which has left the in an invalid state. + You may call the method to put the in the Closed state. + Any other method calls results in an being thrown. + + + + + The method has been called. + + + + + An object is being written. + + + + + A array is being written. + + + + + A constructor is being written. + + + + + A property is being written. + + + + + A write method has not been called. + + + + diff --git a/MoCha/Assets/Plugins/Newtonsoft.Json.xml.meta b/MoCha/Assets/Plugins/Newtonsoft.Json.xml.meta new file mode 100644 index 0000000..e527afe --- /dev/null +++ b/MoCha/Assets/Plugins/Newtonsoft.Json.xml.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 4389f1c8a3fe9344886cb991c54bf25a +timeCreated: 1523986568 +licenseType: Free +TextScriptImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: From bff66d911080aae238fb8781cb025f0e20d311f9 Mon Sep 17 00:00:00 2001 From: shadow8t4 Date: Thu, 26 Apr 2018 11:23:43 -0500 Subject: [PATCH 10/13] UI element comment for positioning elements dynamically in scripts. --- MoCha/Assets/Scripts/SceneLoader.cs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/MoCha/Assets/Scripts/SceneLoader.cs b/MoCha/Assets/Scripts/SceneLoader.cs index d61788b..0ed5c19 100644 --- a/MoCha/Assets/Scripts/SceneLoader.cs +++ b/MoCha/Assets/Scripts/SceneLoader.cs @@ -10,6 +10,8 @@ public class SceneLoader : MonoBehaviour { public void Start() { buttontext = GetComponentInChildren (); + // grab a UI element, set its rectTransform.anchoredPosition = to a Vector2 of the new position coordinates. + //buttontext.rectTransform.anchoredPosition = new Vector2(buttontext.rectTransform.anchoredPosition.x, buttontext.rectTransform.anchoredPosition.y + 100); } public void LoadScene() From 6b17d4a60d89229b3115b63abc8687c783f503a9 Mon Sep 17 00:00:00 2001 From: shadow8t4 Date: Thu, 26 Apr 2018 12:40:50 -0500 Subject: [PATCH 11/13] Make goals look nice. --- MoCha/Assets/Scenes/Goals.unity | Bin 30908 -> 48008 bytes MoCha/Assets/Scripts/GetGoals.cs | 13 ++++++++----- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/MoCha/Assets/Scenes/Goals.unity b/MoCha/Assets/Scenes/Goals.unity index 5333b1e135f8d75df9817a9c283fa63a3904413b..539c701b906b8f1a27d13f9683cc7326ece908b5 100644 GIT binary patch delta 9398 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 delta 1508 zcmZXTTS$~!6vy|TTa%8Z<=E(0ikBSAlM{`X9zrV+gX}0xSGw3s9f$+&cgv86gm&*7#!jBUwif!Mjx!b_W!rPz1RBI z+TW!)%k#fwx)9CvLbN;=LS$gx981rXS%bwHImW+hE~glkIse;@3l*^xBVKw)8Y^mN z)1=L?@2Hc~ZfyVYcbl{tg~2^m=`hahskcgLyxw1Bl@??Epx0?F5Q64U1w+2~tri3j zPK>|6+hC=dg~0}(?XWeP`K>~nfOf!oB9m%w57D*8Y zs)+|#Oj|=jq+vcj^ItZzX`JMNUjloh8J|=Hy%aXKtIrE3d|>C{Il-5j4S=14M&HCM z&8l(uUTBUuu2~e!Oy+e+LymX=FD+xcf4UG(G=oLpImmL&rokFn!!k9iMrM3qCd{qb z1F)T}VOg4SW_+2rC4-xTxLb%Z259zuNW*HRYxd62>>ZfdyWce9EX>w5_)AbrXs`fU z%2nk+)Yz6wEp64(K`+|sC_7X^(NGzcg(q-X{|O(KM)$cq3(ehMN>_SUlfQ2{9S^52 z6E#BAzY=5H#@|l*w;ny(wuSO9ep<<;__YKB9{ybO;cMulKO@;xcWJjVe|1LMxsrDJ zIhse^eICiPDmCVj>oMyorKhldR_TTqud|*}`bDf9dREcdSOHyo;)ag3dui+m?~k=_ zz<7i_G}Z3avwi)^nU|vdPHLod#reJK#HYQXa%v3QO8JNCIX1^mJ-D)B{|VYWac>oV zB_YgWI*g`{V-{@5G$y+~NUFWzq`gBP8#jt(u6o*UZ72T)7r7qBUHKwhV;cQ5RJgE= zBC_>s89zPzwv4M(2FZbgC(D@iXiJ)TZ}`t}(7|C`&_Q3n!g(kpvQ0V zR#C!(*``F5)~Kg?V<3@B9no|(|Cq>kb2BT~ud7VPPL2+mN)+U@^3C}n5ZJhGW5vQ% zq!D?_4Y0X6)%AY=cdL0++iA-Pe7k^sO(UvNDtK_jP5b&&sjoAcOb~0jVS3%qevxho zm3I}VE@%-Q?kdKo{WVgf-u8_aK{br7#n`IGyQ3R0|6{ZSqkOhjT~yw`u;pI>Q4(JD diff --git a/MoCha/Assets/Scripts/GetGoals.cs b/MoCha/Assets/Scripts/GetGoals.cs index 85d3e1a..6ffadb3 100644 --- a/MoCha/Assets/Scripts/GetGoals.cs +++ b/MoCha/Assets/Scripts/GetGoals.cs @@ -9,7 +9,8 @@ using UnityEngine.UI; namespace PedometerU.Tests { public class GetGoals : MonoBehaviour { - + + public Image background; public Text goalText; public string currentDayStr = System.DateTime.Now.ToString("MM/dd/yyyy"); public string goalDayStr = System.DateTime.Now.ToString("MM/dd/yyyy"); @@ -18,7 +19,7 @@ public class GetGoals : MonoBehaviour { //Progress Bar... public float barDisplay; //current progress private Vector2 barPos; - private Vector2 barSize = new Vector2(227,20); + private Vector2 barSize = new Vector2(725, 39); //Pedometer private Pedometer pedometer; @@ -76,8 +77,9 @@ public class GetGoals : MonoBehaviour { //goalText.text = prefKey; goalText.color = new Color(0f, 0f, 0f); - Debug.Log(goalText.transform.position.x.ToString() + " " + goalText.transform.position.y.ToString()); - barPos = new Vector2(goalText.transform.position.x, goalText.transform.position.y); + Debug.Log(background.rectTransform.anchoredPosition.x.ToString() + " " + background.rectTransform.anchoredPosition.y.ToString()); + + barPos = new Vector2(background.transform.position.x, 2135 - background.transform.position.y); currentDayStr = System.DateTime.Now.ToString("MM/dd/yyyy"); goalDayStr = System.DateTime.Now.ToString("MM/dd/yyyy"); @@ -109,7 +111,7 @@ public class GetGoals : MonoBehaviour { return false; return true; } - + // void OnGUI() { //draw the background: GUI.BeginGroup(new Rect(barPos.x, barPos.y, barSize.x, barSize.y)); @@ -122,6 +124,7 @@ public class GetGoals : MonoBehaviour { GUI.EndGroup(); } + void Update() { //needs current points counting toward this goal (daily?) //needs the total required points for this goal From 57f3955debbfc9e701415a8c3784476de42f8843 Mon Sep 17 00:00:00 2001 From: darrelmarek Date: Thu, 26 Apr 2018 12:51:50 -0500 Subject: [PATCH 12/13] removed redundant items on monstercreator scene --- MoCha/Assets/Scenes/MonsterCreator.unity | Bin 98268 -> 97100 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/MoCha/Assets/Scenes/MonsterCreator.unity b/MoCha/Assets/Scenes/MonsterCreator.unity index becd2aa4789783ca50412c3df68467ece74d676a..d0e451adbb5de83811e7fe2b56af2634942ffd4f 100644 GIT binary patch delta 3404 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 From 44601503d2bc5480ec0b195f342774a65f4a2400 Mon Sep 17 00:00:00 2001 From: shadow8t4 Date: Thu, 26 Apr 2018 13:07:25 -0500 Subject: [PATCH 13/13] fine. --- MoCha/Assets/Scenes/Home.unity | Bin 91292 -> 90388 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/MoCha/Assets/Scenes/Home.unity b/MoCha/Assets/Scenes/Home.unity index c6a8bad1020cac3db274e3a9367d59fc67588cab..e8de8a3ab31a7bc1aba259fba04ffaabd131e65a 100644 GIT binary patch delta 3342 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 Kud#|8DE$vLGwgQ&