- Layer 53

- Fix bug in generator
- Fix DC switching
- change default server

TeleSharp.TL/TL/Account/TLRequestConfirmPhone.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Account
+{
+	[TLObject(1596029123)]
+    public class TLRequestConfirmPhone : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1596029123;
+            }
+        }
+
+                public string phone_code_hash {get;set;}
+        public string phone_code {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            phone_code_hash = StringUtil.Deserialize(br);
+phone_code = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(phone_code_hash,bw);
+StringUtil.Serialize(phone_code,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestSendConfirmPhoneCode.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Account
+{
+	[TLObject(353818557)]
+    public class TLRequestSendConfirmPhoneCode : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 353818557;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool allow_flashcall {get;set;}
+        public string hash {get;set;}
+        public bool? current_number {get;set;}
+        public Auth.TLSentCode Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = allow_flashcall ? (flags | 1) : (flags & ~1);
+flags = current_number != null ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+allow_flashcall = (flags & 1) != 0;
+hash = StringUtil.Deserialize(br);
+if ((flags & 1) != 0)
+current_number = BoolUtil.Deserialize(br);
+else
+current_number = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+StringUtil.Serialize(hash,bw);
+if ((flags & 1) != 0)
+BoolUtil.Serialize(current_number.Value,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Auth.TLSentCode)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLAuthorization.cs

@@ -7,35 +7,49 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL.Auth
 {
-	[TLObject(-16553231)]
+	[TLObject(-855308010)]
     public class TLAuthorization : TLObject
     {
         public override int Constructor
         {
             get
             {
-                return -16553231;
+                return -855308010;
             }
         }
 
-             public TLAbsUser user {get;set;}
+             public int flags {get;set;}
+     public int? tmp_sessions {get;set;}
+     public TLAbsUser user {get;set;}
 
 
 		public void ComputeFlags()
 		{
-			
+			flags = 0;
+flags = tmp_sessions != null ? (flags | 1) : (flags & ~1);
+
 		}
 
         public override void DeserializeBody(BinaryReader br)
         {
-            user = (TLAbsUser)ObjectUtils.DeserializeObject(br);
+            flags = br.ReadInt32();
+if ((flags & 1) != 0)
+tmp_sessions = br.ReadInt32();
+else
+tmp_sessions = null;
+
+user = (TLAbsUser)ObjectUtils.DeserializeObject(br);
 
         }
 
         public override void SerializeBody(BinaryWriter bw)
         {
 			bw.Write(Constructor);
-            ObjectUtils.SerializeObject(user,bw);
+            ComputeFlags();
+bw.Write(flags);
+if ((flags & 1) != 0)
+bw.Write(tmp_sessions.Value);
+ObjectUtils.SerializeObject(user,bw);
 
         }
     }

TeleSharp.TL/TL/Auth/TLRequestDropTempAuthKeys.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Auth
+{
+	[TLObject(-1907842680)]
+    public class TLRequestDropTempAuthKeys : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1907842680;
+            }
+        }
+
+                public TLVector<long> except_auth_keys {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            except_auth_keys = (TLVector<long>)ObjectUtils.DeserializeVector<long>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(except_auth_keys,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestGetAdminedPublicChannels.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Channels
+{
+	[TLObject(-1920105769)]
+    public class TLRequestGetAdminedPublicChannels : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1920105769;
+            }
+        }
+
+                public Messages.TLChats Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLChats)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Contacts/TLRequestImportContacts.cs

@@ -30,7 +30,7 @@ namespace TeleSharp.TL.Contacts
 
         public override void DeserializeBody(BinaryReader br)
         {
-            contacts = ObjectUtils.DeserializeVector<TLInputPhoneContact>(br);
+            contacts = (TLVector<TLInputPhoneContact>)ObjectUtils.DeserializeVector<TLInputPhoneContact>(br);
 replace = BoolUtil.Deserialize(br);
 
         }

TeleSharp.TL/TL/Messages/TLAbsFeaturedStickers.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+    public abstract class TLAbsFeaturedStickers : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Messages/TLAbsRecentStickers.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+    public abstract class TLAbsRecentStickers : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Messages/TLAbsStickerSetInstallResult.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+    public abstract class TLAbsStickerSetInstallResult : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Messages/TLArchivedStickers.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(1338747336)]
+    public class TLArchivedStickers : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1338747336;
+            }
+        }
+
+             public int count {get;set;}
+     public TLVector<TLAbsStickerSetCovered> sets {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            count = br.ReadInt32();
+sets = (TLVector<TLAbsStickerSetCovered>)ObjectUtils.DeserializeVector<TLAbsStickerSetCovered>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(count);
+ObjectUtils.SerializeObject(sets,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLBotCallbackAnswer.cs

@@ -7,27 +7,31 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL.Messages
 {
-	[TLObject(308605382)]
+	[TLObject(-1324486149)]
     public class TLBotCallbackAnswer : TLObject
     {
         public override int Constructor
         {
             get
             {
-                return 308605382;
+                return -1324486149;
             }
         }
 
              public int flags {get;set;}
      public bool alert {get;set;}
+     public bool has_url {get;set;}
      public string message {get;set;}
+     public string url {get;set;}
 
 
 		public void ComputeFlags()
 		{
 			flags = 0;
 flags = alert ? (flags | 2) : (flags & ~2);
+flags = has_url ? (flags | 8) : (flags & ~8);
 flags = message != null ? (flags | 1) : (flags & ~1);
+flags = url != null ? (flags | 4) : (flags & ~4);
 
 		}
 
@@ -35,11 +39,17 @@ flags = message != null ? (flags | 1) : (flags & ~1);
         {
             flags = br.ReadInt32();
 alert = (flags & 2) != 0;
+has_url = (flags & 8) != 0;
 if ((flags & 1) != 0)
 message = StringUtil.Deserialize(br);
 else
 message = null;
 
+if ((flags & 4) != 0)
+url = StringUtil.Deserialize(br);
+else
+url = null;
+
 
         }
 
@@ -49,8 +59,11 @@ message = null;
             ComputeFlags();
 bw.Write(flags);
 
+
 if ((flags & 1) != 0)
 StringUtil.Serialize(message,bw);
+if ((flags & 4) != 0)
+StringUtil.Serialize(url,bw);
 
         }
     }

TeleSharp.TL/TL/Messages/TLFeaturedStickers.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(-123893531)]
+    public class TLFeaturedStickers : TLAbsFeaturedStickers
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -123893531;
+            }
+        }
+
+             public int hash {get;set;}
+     public TLVector<TLAbsStickerSetCovered> sets {get;set;}
+     public TLVector<long> unread {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            hash = br.ReadInt32();
+sets = (TLVector<TLAbsStickerSetCovered>)ObjectUtils.DeserializeVector<TLAbsStickerSetCovered>(br);
+unread = (TLVector<long>)ObjectUtils.DeserializeVector<long>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(hash);
+ObjectUtils.SerializeObject(sets,bw);
+ObjectUtils.SerializeObject(unread,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLFeaturedStickersNotModified.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(82699215)]
+    public class TLFeaturedStickersNotModified : TLAbsFeaturedStickers
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 82699215;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLHighScores.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(-1707344487)]
+    public class TLHighScores : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1707344487;
+            }
+        }
+
+             public TLVector<TLHighScore> scores {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            scores = (TLVector<TLHighScore>)ObjectUtils.DeserializeVector<TLHighScore>(br);
+users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(scores,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLRecentStickers.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(1558317424)]
+    public class TLRecentStickers : TLAbsRecentStickers
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1558317424;
+            }
+        }
+
+             public int hash {get;set;}
+     public TLVector<TLAbsDocument> stickers {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            hash = br.ReadInt32();
+stickers = (TLVector<TLAbsDocument>)ObjectUtils.DeserializeVector<TLAbsDocument>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(hash);
+ObjectUtils.SerializeObject(stickers,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLRecentStickersNotModified.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(186120336)]
+    public class TLRecentStickersNotModified : TLAbsRecentStickers
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 186120336;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestClearRecentStickers.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(-1986437075)]
+    public class TLRequestClearRecentStickers : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1986437075;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool attached {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = attached ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+attached = (flags & 1) != 0;
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestForwardMessages.cs

@@ -21,6 +21,7 @@ namespace TeleSharp.TL.Messages
                 public int flags {get;set;}
         public bool silent {get;set;}
         public bool background {get;set;}
+        public bool with_my_score {get;set;}
         public TLAbsInputPeer from_peer {get;set;}
         public TLVector<int> id {get;set;}
         public TLVector<long> random_id {get;set;}
@@ -33,6 +34,7 @@ namespace TeleSharp.TL.Messages
 			flags = 0;
 flags = silent ? (flags | 32) : (flags & ~32);
 flags = background ? (flags | 64) : (flags & ~64);
+flags = with_my_score ? (flags | 256) : (flags & ~256);
 
 		}
 
@@ -41,6 +43,7 @@ flags = background ? (flags | 64) : (flags & ~64);
             flags = br.ReadInt32();
 silent = (flags & 32) != 0;
 background = (flags & 64) != 0;
+with_my_score = (flags & 256) != 0;
 from_peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
 id = (TLVector<int>)ObjectUtils.DeserializeVector<int>(br);
 random_id = (TLVector<long>)ObjectUtils.DeserializeVector<long>(br);
@@ -55,6 +58,7 @@ to_peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
 bw.Write(flags);
 
 
+
 ObjectUtils.SerializeObject(from_peer,bw);
 ObjectUtils.SerializeObject(id,bw);
 ObjectUtils.SerializeObject(random_id,bw);

TeleSharp.TL/TL/Messages/TLRequestGetArchivedStickers.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(1475442322)]
+    public class TLRequestGetArchivedStickers : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1475442322;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool masks {get;set;}
+        public long offset_id {get;set;}
+        public int limit {get;set;}
+        public Messages.TLArchivedStickers Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = masks ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+masks = (flags & 1) != 0;
+offset_id = br.ReadInt64();
+limit = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+bw.Write(offset_id);
+bw.Write(limit);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLArchivedStickers)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetAttachedStickers.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(-866424884)]
+    public class TLRequestGetAttachedStickers : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -866424884;
+            }
+        }
+
+                public TLAbsInputStickeredMedia media {get;set;}
+        public TLVector<TLAbsStickerSetCovered> Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            media = (TLAbsInputStickeredMedia)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(media,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLVector<TLAbsStickerSetCovered>)ObjectUtils.DeserializeVector<TLAbsStickerSetCovered>(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetBotCallbackAnswer.cs

@@ -7,18 +7,20 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL.Messages
 {
-	[TLObject(-1494659324)]
+	[TLObject(-2130010132)]
     public class TLRequestGetBotCallbackAnswer : TLMethod
     {
         public override int Constructor
         {
             get
             {
-                return -1494659324;
+                return -2130010132;
             }
         }
 
-                public TLAbsInputPeer peer {get;set;}
+                public int flags {get;set;}
+        public bool game {get;set;}
+        public TLAbsInputPeer peer {get;set;}
         public int msg_id {get;set;}
         public byte[] data {get;set;}
         public Messages.TLBotCallbackAnswer Response{ get; set;}
@@ -26,22 +28,35 @@ namespace TeleSharp.TL.Messages
 
 		public void ComputeFlags()
 		{
-			
+			flags = 0;
+flags = game ? (flags | 2) : (flags & ~2);
+flags = data != null ? (flags | 1) : (flags & ~1);
+
 		}
 
         public override void DeserializeBody(BinaryReader br)
         {
-            peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+            flags = br.ReadInt32();
+game = (flags & 2) != 0;
+peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
 msg_id = br.ReadInt32();
+if ((flags & 1) != 0)
 data = BytesUtil.Deserialize(br);
+else
+data = null;
+
 
         }
 
         public override void SerializeBody(BinaryWriter bw)
         {
 			bw.Write(Constructor);
-            ObjectUtils.SerializeObject(peer,bw);
+            ComputeFlags();
+bw.Write(flags);
+
+ObjectUtils.SerializeObject(peer,bw);
 bw.Write(msg_id);
+if ((flags & 1) != 0)
 BytesUtil.Serialize(data,bw);
 
         }

TeleSharp.TL/TL/Messages/TLRequestGetFeaturedStickers.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(766298703)]
+    public class TLRequestGetFeaturedStickers : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 766298703;
+            }
+        }
+
+                public int hash {get;set;}
+        public Messages.TLAbsFeaturedStickers Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            hash = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(hash);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsFeaturedStickers)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetGameHighScores.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(-400399203)]
+    public class TLRequestGetGameHighScores : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -400399203;
+            }
+        }
+
+                public TLAbsInputPeer peer {get;set;}
+        public int id {get;set;}
+        public TLAbsInputUser user_id {get;set;}
+        public Messages.TLHighScores Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+id = br.ReadInt32();
+user_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+bw.Write(id);
+ObjectUtils.SerializeObject(user_id,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLHighScores)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetInlineGameHighScores.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(258170395)]
+    public class TLRequestGetInlineGameHighScores : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 258170395;
+            }
+        }
+
+                public TLInputBotInlineMessageID id {get;set;}
+        public TLAbsInputUser user_id {get;set;}
+        public Messages.TLHighScores Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            id = (TLInputBotInlineMessageID)ObjectUtils.DeserializeObject(br);
+user_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(id,bw);
+ObjectUtils.SerializeObject(user_id,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLHighScores)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetMaskStickers.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(1706608543)]
+    public class TLRequestGetMaskStickers : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1706608543;
+            }
+        }
+
+                public int hash {get;set;}
+        public Messages.TLAbsAllStickers Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            hash = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(hash);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsAllStickers)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetRecentStickers.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(1587647177)]
+    public class TLRequestGetRecentStickers : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1587647177;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool attached {get;set;}
+        public int hash {get;set;}
+        public Messages.TLAbsRecentStickers Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = attached ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+attached = (flags & 1) != 0;
+hash = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+bw.Write(hash);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsRecentStickers)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestInstallStickerSet.cs

@@ -7,20 +7,20 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL.Messages
 {
-	[TLObject(2066793382)]
+	[TLObject(-946871200)]
     public class TLRequestInstallStickerSet : TLMethod
     {
         public override int Constructor
         {
             get
             {
-                return 2066793382;
+                return -946871200;
             }
         }
 
                 public TLAbsInputStickerSet stickerset {get;set;}
-        public bool disabled {get;set;}
-        public bool Response{ get; set;}
+        public bool archived {get;set;}
+        public Messages.TLAbsStickerSetInstallResult Response{ get; set;}
 
 
 		public void ComputeFlags()
@@ -31,7 +31,7 @@ namespace TeleSharp.TL.Messages
         public override void DeserializeBody(BinaryReader br)
         {
             stickerset = (TLAbsInputStickerSet)ObjectUtils.DeserializeObject(br);
-disabled = BoolUtil.Deserialize(br);
+archived = BoolUtil.Deserialize(br);
 
         }
 
@@ -39,12 +39,12 @@ disabled = BoolUtil.Deserialize(br);
         {
 			bw.Write(Constructor);
             ObjectUtils.SerializeObject(stickerset,bw);
-BoolUtil.Serialize(disabled,bw);
+BoolUtil.Serialize(archived,bw);
 
         }
 		public override void deserializeResponse(BinaryReader br)
 		{
-			Response = BoolUtil.Deserialize(br);
+			Response = (Messages.TLAbsStickerSetInstallResult)ObjectUtils.DeserializeObject(br);
 
 		}
     }

TeleSharp.TL/TL/Messages/TLRequestReadFeaturedStickers.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(1527873830)]
+    public class TLRequestReadFeaturedStickers : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1527873830;
+            }
+        }
+
+                public TLVector<long> id {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            id = (TLVector<long>)ObjectUtils.DeserializeVector<long>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(id,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestReorderStickerSets.cs

@@ -7,36 +7,45 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL.Messages
 {
-	[TLObject(-1613775824)]
+	[TLObject(2016638777)]
     public class TLRequestReorderStickerSets : TLMethod
     {
         public override int Constructor
         {
             get
             {
-                return -1613775824;
+                return 2016638777;
             }
         }
 
-                public TLVector<long> order {get;set;}
+                public int flags {get;set;}
+        public bool masks {get;set;}
+        public TLVector<long> order {get;set;}
         public bool Response{ get; set;}
 
 
 		public void ComputeFlags()
 		{
-			
+			flags = 0;
+flags = masks ? (flags | 1) : (flags & ~1);
+
 		}
 
         public override void DeserializeBody(BinaryReader br)
         {
-            order = (TLVector<long>)ObjectUtils.DeserializeVector<long>(br);
+            flags = br.ReadInt32();
+masks = (flags & 1) != 0;
+order = (TLVector<long>)ObjectUtils.DeserializeVector<long>(br);
 
         }
 
         public override void SerializeBody(BinaryWriter bw)
         {
 			bw.Write(Constructor);
-            ObjectUtils.SerializeObject(order,bw);
+            ComputeFlags();
+bw.Write(flags);
+
+ObjectUtils.SerializeObject(order,bw);
 
         }
 		public override void deserializeResponse(BinaryReader br)

TeleSharp.TL/TL/Messages/TLRequestSaveRecentSticker.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(958863608)]
+    public class TLRequestSaveRecentSticker : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 958863608;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool attached {get;set;}
+        public TLAbsInputDocument id {get;set;}
+        public bool unsave {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = attached ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+attached = (flags & 1) != 0;
+id = (TLAbsInputDocument)ObjectUtils.DeserializeObject(br);
+unsave = BoolUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+ObjectUtils.SerializeObject(id,bw);
+BoolUtil.Serialize(unsave,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSetBotCallbackAnswer.cs

@@ -7,14 +7,14 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL.Messages
 {
-	[TLObject(1209817370)]
+	[TLObject(-920136629)]
     public class TLRequestSetBotCallbackAnswer : TLMethod
     {
         public override int Constructor
         {
             get
             {
-                return 1209817370;
+                return -920136629;
             }
         }
 
@@ -22,6 +22,7 @@ namespace TeleSharp.TL.Messages
         public bool alert {get;set;}
         public long query_id {get;set;}
         public string message {get;set;}
+        public string url {get;set;}
         public bool Response{ get; set;}
 
 
@@ -30,6 +31,7 @@ namespace TeleSharp.TL.Messages
 			flags = 0;
 flags = alert ? (flags | 2) : (flags & ~2);
 flags = message != null ? (flags | 1) : (flags & ~1);
+flags = url != null ? (flags | 4) : (flags & ~4);
 
 		}
 
@@ -43,6 +45,11 @@ message = StringUtil.Deserialize(br);
 else
 message = null;
 
+if ((flags & 4) != 0)
+url = StringUtil.Deserialize(br);
+else
+url = null;
+
 
         }
 
@@ -55,6 +62,8 @@ bw.Write(flags);
 bw.Write(query_id);
 if ((flags & 1) != 0)
 StringUtil.Serialize(message,bw);
+if ((flags & 4) != 0)
+StringUtil.Serialize(url,bw);
 
         }
 		public override void deserializeResponse(BinaryReader br)

TeleSharp.TL/TL/Messages/TLRequestSetGameScore.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(-1896289088)]
+    public class TLRequestSetGameScore : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1896289088;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool edit_message {get;set;}
+        public TLAbsInputPeer peer {get;set;}
+        public int id {get;set;}
+        public TLAbsInputUser user_id {get;set;}
+        public int score {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = edit_message ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+edit_message = (flags & 1) != 0;
+peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+id = br.ReadInt32();
+user_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+score = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+ObjectUtils.SerializeObject(peer,bw);
+bw.Write(id);
+ObjectUtils.SerializeObject(user_id,bw);
+bw.Write(score);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSetInlineGameScore.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(363700068)]
+    public class TLRequestSetInlineGameScore : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 363700068;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool edit_message {get;set;}
+        public TLInputBotInlineMessageID id {get;set;}
+        public TLAbsInputUser user_id {get;set;}
+        public int score {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = edit_message ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+edit_message = (flags & 1) != 0;
+id = (TLInputBotInlineMessageID)ObjectUtils.DeserializeObject(br);
+user_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+score = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+ObjectUtils.SerializeObject(id,bw);
+ObjectUtils.SerializeObject(user_id,bw);
+bw.Write(score);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLStickerSetInstallResultArchive.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(904138920)]
+    public class TLStickerSetInstallResultArchive : TLAbsStickerSetInstallResult
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 904138920;
+            }
+        }
+
+             public TLVector<TLAbsStickerSetCovered> sets {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            sets = (TLVector<TLAbsStickerSetCovered>)ObjectUtils.DeserializeVector<TLAbsStickerSetCovered>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(sets,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLStickerSetInstallResultSuccess.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(946083368)]
+    public class TLStickerSetInstallResultSuccess : TLAbsStickerSetInstallResult
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 946083368;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/Photos/TLRequestUpdateProfilePhoto.cs

@@ -7,19 +7,18 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL.Photos
 {
-	[TLObject(-285902432)]
+	[TLObject(-256159406)]
     public class TLRequestUpdateProfilePhoto : TLMethod
     {
         public override int Constructor
         {
             get
             {
-                return -285902432;
+                return -256159406;
             }
         }
 
                 public TLAbsInputPhoto id {get;set;}
-        public TLAbsInputPhotoCrop crop {get;set;}
         public TLAbsUserProfilePhoto Response{ get; set;}
 
 
@@ -31,7 +30,6 @@ namespace TeleSharp.TL.Photos
         public override void DeserializeBody(BinaryReader br)
         {
             id = (TLAbsInputPhoto)ObjectUtils.DeserializeObject(br);
-crop = (TLAbsInputPhotoCrop)ObjectUtils.DeserializeObject(br);
 
         }
 
@@ -39,7 +37,6 @@ crop = (TLAbsInputPhotoCrop)ObjectUtils.DeserializeObject(br);
         {
 			bw.Write(Constructor);
             ObjectUtils.SerializeObject(id,bw);
-ObjectUtils.SerializeObject(crop,bw);
 
         }
 		public override void deserializeResponse(BinaryReader br)

TeleSharp.TL/TL/Photos/TLRequestUploadProfilePhoto.cs

@@ -7,21 +7,18 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL.Photos
 {
-	[TLObject(-720397176)]
+	[TLObject(1328726168)]
     public class TLRequestUploadProfilePhoto : TLMethod
     {
         public override int Constructor
         {
             get
             {
-                return -720397176;
+                return 1328726168;
             }
         }
 
                 public TLAbsInputFile file {get;set;}
-        public string caption {get;set;}
-        public TLAbsInputGeoPoint geo_point {get;set;}
-        public TLAbsInputPhotoCrop crop {get;set;}
         public Photos.TLPhoto Response{ get; set;}
 
 
@@ -33,9 +30,6 @@ namespace TeleSharp.TL.Photos
         public override void DeserializeBody(BinaryReader br)
         {
             file = (TLAbsInputFile)ObjectUtils.DeserializeObject(br);
-caption = StringUtil.Deserialize(br);
-geo_point = (TLAbsInputGeoPoint)ObjectUtils.DeserializeObject(br);
-crop = (TLAbsInputPhotoCrop)ObjectUtils.DeserializeObject(br);
 
         }
 
@@ -43,9 +37,6 @@ crop = (TLAbsInputPhotoCrop)ObjectUtils.DeserializeObject(br);
         {
 			bw.Write(Constructor);
             ObjectUtils.SerializeObject(file,bw);
-StringUtil.Serialize(caption,bw);
-ObjectUtils.SerializeObject(geo_point,bw);
-ObjectUtils.SerializeObject(crop,bw);
 
         }
 		public override void deserializeResponse(BinaryReader br)

TeleSharp.TL/TL/TLAbsInputGame.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+    public abstract class TLAbsInputGame : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/TLAbsInputStickeredMedia.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+    public abstract class TLAbsInputStickeredMedia : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/TLAbsStickerSetCovered.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+    public abstract class TLAbsStickerSetCovered : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/TLChatInvite.cs

@@ -7,14 +7,14 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(-1813406880)]
+	[TLObject(-613092008)]
     public class TLChatInvite : TLAbsChatInvite
     {
         public override int Constructor
         {
             get
             {
-                return -1813406880;
+                return -613092008;
             }
         }
 
@@ -24,6 +24,9 @@ namespace TeleSharp.TL
      public bool @public {get;set;}
      public bool megagroup {get;set;}
      public string title {get;set;}
+     public TLAbsChatPhoto photo {get;set;}
+     public int participants_count {get;set;}
+     public TLVector<TLAbsUser> participants {get;set;}
 
 
 		public void ComputeFlags()
@@ -33,6 +36,7 @@ flags = channel ? (flags | 1) : (flags & ~1);
 flags = broadcast ? (flags | 2) : (flags & ~2);
 flags = @public ? (flags | 4) : (flags & ~4);
 flags = megagroup ? (flags | 8) : (flags & ~8);
+flags = participants != null ? (flags | 16) : (flags & ~16);
 
 		}
 
@@ -44,6 +48,13 @@ broadcast = (flags & 2) != 0;
 @public = (flags & 4) != 0;
 megagroup = (flags & 8) != 0;
 title = StringUtil.Deserialize(br);
+photo = (TLAbsChatPhoto)ObjectUtils.DeserializeObject(br);
+participants_count = br.ReadInt32();
+if ((flags & 16) != 0)
+participants = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
+else
+participants = null;
+
 
         }
 
@@ -57,6 +68,10 @@ bw.Write(flags);
 
 
 StringUtil.Serialize(title,bw);
+ObjectUtils.SerializeObject(photo,bw);
+bw.Write(participants_count);
+if ((flags & 16) != 0)
+ObjectUtils.SerializeObject(participants,bw);
 
         }
     }

TeleSharp.TL/TL/TLConfig.cs

@@ -7,18 +7,19 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(-918482040)]
+	[TLObject(-1704251862)]
     public class TLConfig : TLObject
     {
         public override int Constructor
         {
             get
             {
-                return -918482040;
+                return -1704251862;
             }
         }
 
-             public int date {get;set;}
+             public int flags {get;set;}
+     public int date {get;set;}
      public int expires {get;set;}
      public bool test_mode {get;set;}
      public int this_dc {get;set;}
@@ -38,17 +39,22 @@ namespace TeleSharp.TL
      public int saved_gifs_limit {get;set;}
      public int edit_time_limit {get;set;}
      public int rating_e_decay {get;set;}
+     public int stickers_recent_limit {get;set;}
+     public int? tmp_sessions {get;set;}
      public TLVector<TLDisabledFeature> disabled_features {get;set;}
 
 
 		public void ComputeFlags()
 		{
-			
+			flags = 0;
+flags = tmp_sessions != null ? (flags | 1) : (flags & ~1);
+
 		}
 
         public override void DeserializeBody(BinaryReader br)
         {
-            date = br.ReadInt32();
+            flags = br.ReadInt32();
+date = br.ReadInt32();
 expires = br.ReadInt32();
 test_mode = BoolUtil.Deserialize(br);
 this_dc = br.ReadInt32();
@@ -68,6 +74,12 @@ push_chat_limit = br.ReadInt32();
 saved_gifs_limit = br.ReadInt32();
 edit_time_limit = br.ReadInt32();
 rating_e_decay = br.ReadInt32();
+stickers_recent_limit = br.ReadInt32();
+if ((flags & 1) != 0)
+tmp_sessions = br.ReadInt32();
+else
+tmp_sessions = null;
+
 disabled_features = (TLVector<TLDisabledFeature>)ObjectUtils.DeserializeVector<TLDisabledFeature>(br);
 
         }
@@ -75,7 +87,9 @@ disabled_features = (TLVector<TLDisabledFeature>)ObjectUtils.DeserializeVector<T
         public override void SerializeBody(BinaryWriter bw)
         {
 			bw.Write(Constructor);
-            bw.Write(date);
+            ComputeFlags();
+bw.Write(flags);
+bw.Write(date);
 bw.Write(expires);
 BoolUtil.Serialize(test_mode,bw);
 bw.Write(this_dc);
@@ -95,6 +109,9 @@ bw.Write(push_chat_limit);
 bw.Write(saved_gifs_limit);
 bw.Write(edit_time_limit);
 bw.Write(rating_e_decay);
+bw.Write(stickers_recent_limit);
+if ((flags & 1) != 0)
+bw.Write(tmp_sessions.Value);
 ObjectUtils.SerializeObject(disabled_features,bw);
 
         }

TeleSharp.TL/TL/TLDocument.cs

@@ -7,14 +7,14 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(-106717361)]
+	[TLObject(-2027738169)]
     public class TLDocument : TLAbsDocument
     {
         public override int Constructor
         {
             get
             {
-                return -106717361;
+                return -2027738169;
             }
         }
 
@@ -25,6 +25,7 @@ namespace TeleSharp.TL
      public int size {get;set;}
      public TLAbsPhotoSize thumb {get;set;}
      public int dc_id {get;set;}
+     public int version {get;set;}
      public TLVector<TLAbsDocumentAttribute> attributes {get;set;}
 
 
@@ -42,6 +43,7 @@ mime_type = StringUtil.Deserialize(br);
 size = br.ReadInt32();
 thumb = (TLAbsPhotoSize)ObjectUtils.DeserializeObject(br);
 dc_id = br.ReadInt32();
+version = br.ReadInt32();
 attributes = (TLVector<TLAbsDocumentAttribute>)ObjectUtils.DeserializeVector<TLAbsDocumentAttribute>(br);
 
         }
@@ -56,6 +58,7 @@ StringUtil.Serialize(mime_type,bw);
 bw.Write(size);
 ObjectUtils.SerializeObject(thumb,bw);
 bw.Write(dc_id);
+bw.Write(version);
 ObjectUtils.SerializeObject(attributes,bw);
 
         }

TeleSharp.TL/TL/TLDocumentAttributeHasStickers.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(-1744710921)]
+    public class TLDocumentAttributeHasStickers : TLAbsDocumentAttribute
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1744710921;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/TLDocumentAttributeSticker.cs

@@ -7,38 +7,56 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(978674434)]
+	[TLObject(1662637586)]
     public class TLDocumentAttributeSticker : TLAbsDocumentAttribute
     {
         public override int Constructor
         {
             get
             {
-                return 978674434;
+                return 1662637586;
             }
         }
 
-             public string alt {get;set;}
+             public int flags {get;set;}
+     public bool mask {get;set;}
+     public string alt {get;set;}
      public TLAbsInputStickerSet stickerset {get;set;}
+     public TLMaskCoords mask_coords {get;set;}
 
 
 		public void ComputeFlags()
 		{
-			
+			flags = 0;
+flags = mask ? (flags | 2) : (flags & ~2);
+flags = mask_coords != null ? (flags | 1) : (flags & ~1);
+
 		}
 
         public override void DeserializeBody(BinaryReader br)
         {
-            alt = StringUtil.Deserialize(br);
+            flags = br.ReadInt32();
+mask = (flags & 2) != 0;
+alt = StringUtil.Deserialize(br);
 stickerset = (TLAbsInputStickerSet)ObjectUtils.DeserializeObject(br);
+if ((flags & 1) != 0)
+mask_coords = (TLMaskCoords)ObjectUtils.DeserializeObject(br);
+else
+mask_coords = null;
+
 
         }
 
         public override void SerializeBody(BinaryWriter bw)
         {
 			bw.Write(Constructor);
-            StringUtil.Serialize(alt,bw);
+            ComputeFlags();
+bw.Write(flags);
+
+StringUtil.Serialize(alt,bw);
 ObjectUtils.SerializeObject(stickerset,bw);
+if ((flags & 1) != 0)
+ObjectUtils.SerializeObject(mask_coords,bw);
 
         }
     }

TeleSharp.TL/TL/TLGame.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(-1107729093)]
+    public class TLGame : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1107729093;
+            }
+        }
+
+             public int flags {get;set;}
+     public long id {get;set;}
+     public long access_hash {get;set;}
+     public string short_name {get;set;}
+     public string title {get;set;}
+     public string description {get;set;}
+     public TLAbsPhoto photo {get;set;}
+     public TLAbsDocument document {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = document != null ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+id = br.ReadInt64();
+access_hash = br.ReadInt64();
+short_name = StringUtil.Deserialize(br);
+title = StringUtil.Deserialize(br);
+description = StringUtil.Deserialize(br);
+photo = (TLAbsPhoto)ObjectUtils.DeserializeObject(br);
+if ((flags & 1) != 0)
+document = (TLAbsDocument)ObjectUtils.DeserializeObject(br);
+else
+document = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+bw.Write(id);
+bw.Write(access_hash);
+StringUtil.Serialize(short_name,bw);
+StringUtil.Serialize(title,bw);
+StringUtil.Serialize(description,bw);
+ObjectUtils.SerializeObject(photo,bw);
+if ((flags & 1) != 0)
+ObjectUtils.SerializeObject(document,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLHighScore.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(1493171408)]
+    public class TLHighScore : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1493171408;
+            }
+        }
+
+             public int pos {get;set;}
+     public int user_id {get;set;}
+     public int score {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            pos = br.ReadInt32();
+user_id = br.ReadInt32();
+score = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(pos);
+bw.Write(user_id);
+bw.Write(score);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLInputBotInlineMessageGame.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(1262639204)]
+    public class TLInputBotInlineMessageGame : TLAbsInputBotInlineMessage
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1262639204;
+            }
+        }
+
+             public int flags {get;set;}
+     public TLAbsReplyMarkup reply_markup {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = reply_markup != null ? (flags | 4) : (flags & ~4);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+if ((flags & 4) != 0)
+reply_markup = (TLAbsReplyMarkup)ObjectUtils.DeserializeObject(br);
+else
+reply_markup = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+if ((flags & 4) != 0)
+ObjectUtils.SerializeObject(reply_markup,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLInputBotInlineResultGame.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(1336154098)]
+    public class TLInputBotInlineResultGame : TLAbsInputBotInlineResult
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1336154098;
+            }
+        }
+
+             public string id {get;set;}
+     public string short_name {get;set;}
+     public TLAbsInputBotInlineMessage send_message {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            id = StringUtil.Deserialize(br);
+short_name = StringUtil.Deserialize(br);
+send_message = (TLAbsInputBotInlineMessage)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(id,bw);
+StringUtil.Serialize(short_name,bw);
+ObjectUtils.SerializeObject(send_message,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLInputChatPhoto.cs

@@ -7,19 +7,18 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(-1293828344)]
+	[TLObject(-1991004873)]
     public class TLInputChatPhoto : TLAbsInputChatPhoto
     {
         public override int Constructor
         {
             get
             {
-                return -1293828344;
+                return -1991004873;
             }
         }
 
              public TLAbsInputPhoto id {get;set;}
-     public TLAbsInputPhotoCrop crop {get;set;}
 
 
 		public void ComputeFlags()
@@ -30,7 +29,6 @@ namespace TeleSharp.TL
         public override void DeserializeBody(BinaryReader br)
         {
             id = (TLAbsInputPhoto)ObjectUtils.DeserializeObject(br);
-crop = (TLAbsInputPhotoCrop)ObjectUtils.DeserializeObject(br);
 
         }
 
@@ -38,7 +36,6 @@ crop = (TLAbsInputPhotoCrop)ObjectUtils.DeserializeObject(br);
         {
 			bw.Write(Constructor);
             ObjectUtils.SerializeObject(id,bw);
-ObjectUtils.SerializeObject(crop,bw);
 
         }
     }

TeleSharp.TL/TL/TLInputChatUploadedPhoto.cs

@@ -7,19 +7,18 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(-1809496270)]
+	[TLObject(-1837345356)]
     public class TLInputChatUploadedPhoto : TLAbsInputChatPhoto
     {
         public override int Constructor
         {
             get
             {
-                return -1809496270;
+                return -1837345356;
             }
         }
 
              public TLAbsInputFile file {get;set;}
-     public TLAbsInputPhotoCrop crop {get;set;}
 
 
 		public void ComputeFlags()
@@ -30,7 +29,6 @@ namespace TeleSharp.TL
         public override void DeserializeBody(BinaryReader br)
         {
             file = (TLAbsInputFile)ObjectUtils.DeserializeObject(br);
-crop = (TLAbsInputPhotoCrop)ObjectUtils.DeserializeObject(br);
 
         }
 
@@ -38,7 +36,6 @@ crop = (TLAbsInputPhotoCrop)ObjectUtils.DeserializeObject(br);
         {
 			bw.Write(Constructor);
             ObjectUtils.SerializeObject(file,bw);
-ObjectUtils.SerializeObject(crop,bw);
 
         }
     }

TeleSharp.TL/TL/TLInputDocumentFileLocation.cs

@@ -7,19 +7,20 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(1313188841)]
+	[TLObject(1125058340)]
     public class TLInputDocumentFileLocation : TLAbsInputFileLocation
     {
         public override int Constructor
         {
             get
             {
-                return 1313188841;
+                return 1125058340;
             }
         }
 
              public long id {get;set;}
      public long access_hash {get;set;}
+     public int version {get;set;}
 
 
 		public void ComputeFlags()
@@ -31,6 +32,7 @@ namespace TeleSharp.TL
         {
             id = br.ReadInt64();
 access_hash = br.ReadInt64();
+version = br.ReadInt32();
 
         }
 
@@ -39,6 +41,7 @@ access_hash = br.ReadInt64();
 			bw.Write(Constructor);
             bw.Write(id);
 bw.Write(access_hash);
+bw.Write(version);
 
         }
     }

TeleSharp.TL/TL/TLInputGameID.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(53231223)]
+    public class TLInputGameID : TLAbsInputGame
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 53231223;
+            }
+        }
+
+             public long id {get;set;}
+     public long access_hash {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            id = br.ReadInt64();
+access_hash = br.ReadInt64();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(id);
+bw.Write(access_hash);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLInputGameShortName.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(-1020139510)]
+    public class TLInputGameShortName : TLAbsInputGame
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1020139510;
+            }
+        }
+
+             public TLAbsInputUser bot_id {get;set;}
+     public string short_name {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            bot_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+short_name = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(bot_id,bw);
+StringUtil.Serialize(short_name,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLInputMediaDocumentExternal.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(-437690244)]
+    public class TLInputMediaDocumentExternal : TLAbsInputMedia
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -437690244;
+            }
+        }
+
+             public string url {get;set;}
+     public string caption {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            url = StringUtil.Deserialize(br);
+caption = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(url,bw);
+StringUtil.Serialize(caption,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLInputMediaGame.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(-750828557)]
+    public class TLInputMediaGame : TLAbsInputMedia
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -750828557;
+            }
+        }
+
+             public TLAbsInputGame id {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            id = (TLAbsInputGame)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(id,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLInputMediaPhotoExternal.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(-1252045032)]
+    public class TLInputMediaPhotoExternal : TLAbsInputMedia
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1252045032;
+            }
+        }
+
+             public string url {get;set;}
+     public string caption {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            url = StringUtil.Deserialize(br);
+caption = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(url,bw);
+StringUtil.Serialize(caption,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLInputMediaUploadedDocument.cs

@@ -7,44 +7,58 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(495530093)]
+	[TLObject(-797904407)]
     public class TLInputMediaUploadedDocument : TLAbsInputMedia
     {
         public override int Constructor
         {
             get
             {
-                return 495530093;
+                return -797904407;
             }
         }
 
-             public TLAbsInputFile file {get;set;}
+             public int flags {get;set;}
+     public TLAbsInputFile file {get;set;}
      public string mime_type {get;set;}
      public TLVector<TLAbsDocumentAttribute> attributes {get;set;}
      public string caption {get;set;}
+     public TLVector<TLAbsInputDocument> stickers {get;set;}
 
 
 		public void ComputeFlags()
 		{
-			
+			flags = 0;
+flags = stickers != null ? (flags | 1) : (flags & ~1);
+
 		}
 
         public override void DeserializeBody(BinaryReader br)
         {
-            file = (TLAbsInputFile)ObjectUtils.DeserializeObject(br);
+            flags = br.ReadInt32();
+file = (TLAbsInputFile)ObjectUtils.DeserializeObject(br);
 mime_type = StringUtil.Deserialize(br);
 attributes = (TLVector<TLAbsDocumentAttribute>)ObjectUtils.DeserializeVector<TLAbsDocumentAttribute>(br);
 caption = StringUtil.Deserialize(br);
+if ((flags & 1) != 0)
+stickers = (TLVector<TLAbsInputDocument>)ObjectUtils.DeserializeVector<TLAbsInputDocument>(br);
+else
+stickers = null;
+
 
         }
 
         public override void SerializeBody(BinaryWriter bw)
         {
 			bw.Write(Constructor);
-            ObjectUtils.SerializeObject(file,bw);
+            ComputeFlags();
+bw.Write(flags);
+ObjectUtils.SerializeObject(file,bw);
 StringUtil.Serialize(mime_type,bw);
 ObjectUtils.SerializeObject(attributes,bw);
 StringUtil.Serialize(caption,bw);
+if ((flags & 1) != 0)
+ObjectUtils.SerializeObject(stickers,bw);
 
         }
     }

TeleSharp.TL/TL/TLInputMediaUploadedPhoto.cs

@@ -7,38 +7,52 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(-139464256)]
+	[TLObject(1661770481)]
     public class TLInputMediaUploadedPhoto : TLAbsInputMedia
     {
         public override int Constructor
         {
             get
             {
-                return -139464256;
+                return 1661770481;
             }
         }
 
-             public TLAbsInputFile file {get;set;}
+             public int flags {get;set;}
+     public TLAbsInputFile file {get;set;}
      public string caption {get;set;}
+     public TLVector<TLAbsInputDocument> stickers {get;set;}
 
 
 		public void ComputeFlags()
 		{
-			
+			flags = 0;
+flags = stickers != null ? (flags | 1) : (flags & ~1);
+
 		}
 
         public override void DeserializeBody(BinaryReader br)
         {
-            file = (TLAbsInputFile)ObjectUtils.DeserializeObject(br);
+            flags = br.ReadInt32();
+file = (TLAbsInputFile)ObjectUtils.DeserializeObject(br);
 caption = StringUtil.Deserialize(br);
+if ((flags & 1) != 0)
+stickers = (TLVector<TLAbsInputDocument>)ObjectUtils.DeserializeVector<TLAbsInputDocument>(br);
+else
+stickers = null;
+
 
         }
 
         public override void SerializeBody(BinaryWriter bw)
         {
 			bw.Write(Constructor);
-            ObjectUtils.SerializeObject(file,bw);
+            ComputeFlags();
+bw.Write(flags);
+ObjectUtils.SerializeObject(file,bw);
 StringUtil.Serialize(caption,bw);
+if ((flags & 1) != 0)
+ObjectUtils.SerializeObject(stickers,bw);
 
         }
     }

TeleSharp.TL/TL/TLInputMediaUploadedThumbDocument.cs

@@ -7,47 +7,61 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(-1386138479)]
+	[TLObject(1356369070)]
     public class TLInputMediaUploadedThumbDocument : TLAbsInputMedia
     {
         public override int Constructor
         {
             get
             {
-                return -1386138479;
+                return 1356369070;
             }
         }
 
-             public TLAbsInputFile file {get;set;}
+             public int flags {get;set;}
+     public TLAbsInputFile file {get;set;}
      public TLAbsInputFile thumb {get;set;}
      public string mime_type {get;set;}
      public TLVector<TLAbsDocumentAttribute> attributes {get;set;}
      public string caption {get;set;}
+     public TLVector<TLAbsInputDocument> stickers {get;set;}
 
 
 		public void ComputeFlags()
 		{
-			
+			flags = 0;
+flags = stickers != null ? (flags | 1) : (flags & ~1);
+
 		}
 
         public override void DeserializeBody(BinaryReader br)
         {
-            file = (TLAbsInputFile)ObjectUtils.DeserializeObject(br);
+            flags = br.ReadInt32();
+file = (TLAbsInputFile)ObjectUtils.DeserializeObject(br);
 thumb = (TLAbsInputFile)ObjectUtils.DeserializeObject(br);
 mime_type = StringUtil.Deserialize(br);
 attributes = (TLVector<TLAbsDocumentAttribute>)ObjectUtils.DeserializeVector<TLAbsDocumentAttribute>(br);
 caption = StringUtil.Deserialize(br);
+if ((flags & 1) != 0)
+stickers = (TLVector<TLAbsInputDocument>)ObjectUtils.DeserializeVector<TLAbsInputDocument>(br);
+else
+stickers = null;
+
 
         }
 
         public override void SerializeBody(BinaryWriter bw)
         {
 			bw.Write(Constructor);
-            ObjectUtils.SerializeObject(file,bw);
+            ComputeFlags();
+bw.Write(flags);
+ObjectUtils.SerializeObject(file,bw);
 ObjectUtils.SerializeObject(thumb,bw);
 StringUtil.Serialize(mime_type,bw);
 ObjectUtils.SerializeObject(attributes,bw);
 StringUtil.Serialize(caption,bw);
+if ((flags & 1) != 0)
+ObjectUtils.SerializeObject(stickers,bw);
 
         }
     }

TeleSharp.TL/TL/TLInputStickeredMediaDocument.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(70813275)]
+    public class TLInputStickeredMediaDocument : TLAbsInputStickeredMedia
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 70813275;
+            }
+        }
+
+             public TLAbsInputDocument id {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            id = (TLAbsInputDocument)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(id,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLInputStickeredMediaPhoto.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(1251549527)]
+    public class TLInputStickeredMediaPhoto : TLAbsInputStickeredMedia
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1251549527;
+            }
+        }
+
+             public TLAbsInputPhoto id {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            id = (TLAbsInputPhoto)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(id,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLKeyboardButtonGame.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(1358175439)]
+    public class TLKeyboardButtonGame : TLAbsKeyboardButton
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1358175439;
+            }
+        }
+
+             public string text {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            text = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(text,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLKeyboardButtonSwitchInline.cs

@@ -7,29 +7,35 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(-367298028)]
+	[TLObject(90744648)]
     public class TLKeyboardButtonSwitchInline : TLAbsKeyboardButton
     {
         public override int Constructor
         {
             get
             {
-                return -367298028;
+                return 90744648;
             }
         }
 
-             public string text {get;set;}
+             public int flags {get;set;}
+     public bool same_peer {get;set;}
+     public string text {get;set;}
      public string query {get;set;}
 
 
 		public void ComputeFlags()
 		{
-			
+			flags = 0;
+flags = same_peer ? (flags | 1) : (flags & ~1);
+
 		}
 
         public override void DeserializeBody(BinaryReader br)
         {
-            text = StringUtil.Deserialize(br);
+            flags = br.ReadInt32();
+same_peer = (flags & 1) != 0;
+text = StringUtil.Deserialize(br);
 query = StringUtil.Deserialize(br);
 
         }
@@ -37,7 +43,10 @@ query = StringUtil.Deserialize(br);
         public override void SerializeBody(BinaryWriter bw)
         {
 			bw.Write(Constructor);
-            StringUtil.Serialize(text,bw);
+            ComputeFlags();
+bw.Write(flags);
+
+StringUtil.Serialize(text,bw);
 StringUtil.Serialize(query,bw);
 
         }

TeleSharp.TL/TL/TLMaskCoords.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(-1361650766)]
+    public class TLMaskCoords : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1361650766;
+            }
+        }
+
+             public int n {get;set;}
+     public double x {get;set;}
+     public double y {get;set;}
+     public double zoom {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            n = br.ReadInt32();
+x = br.ReadDouble();
+y = br.ReadDouble();
+zoom = br.ReadDouble();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(n);
+bw.Write(x);
+bw.Write(y);
+bw.Write(zoom);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLMessageActionGameScore.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(-1834538890)]
+    public class TLMessageActionGameScore : TLAbsMessageAction
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1834538890;
+            }
+        }
+
+             public long game_id {get;set;}
+     public int score {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            game_id = br.ReadInt64();
+score = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(game_id);
+bw.Write(score);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLMessageMediaGame.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(-38694904)]
+    public class TLMessageMediaGame : TLAbsMessageMedia
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -38694904;
+            }
+        }
+
+             public TLGame game {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            game = (TLGame)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(game,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLPhoto.cs

@@ -7,18 +7,20 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(-840088834)]
+	[TLObject(-1836524247)]
     public class TLPhoto : TLAbsPhoto
     {
         public override int Constructor
         {
             get
             {
-                return -840088834;
+                return -1836524247;
             }
         }
 
-             public long id {get;set;}
+             public int flags {get;set;}
+     public bool has_stickers {get;set;}
+     public long id {get;set;}
      public long access_hash {get;set;}
      public int date {get;set;}
      public TLVector<TLAbsPhotoSize> sizes {get;set;}
@@ -26,12 +28,16 @@ namespace TeleSharp.TL
 
 		public void ComputeFlags()
 		{
-			
+			flags = 0;
+flags = has_stickers ? (flags | 1) : (flags & ~1);
+
 		}
 
         public override void DeserializeBody(BinaryReader br)
         {
-            id = br.ReadInt64();
+            flags = br.ReadInt32();
+has_stickers = (flags & 1) != 0;
+id = br.ReadInt64();
 access_hash = br.ReadInt64();
 date = br.ReadInt32();
 sizes = (TLVector<TLAbsPhotoSize>)ObjectUtils.DeserializeVector<TLAbsPhotoSize>(br);
@@ -41,7 +47,10 @@ sizes = (TLVector<TLAbsPhotoSize>)ObjectUtils.DeserializeVector<TLAbsPhotoSize>(
         public override void SerializeBody(BinaryWriter bw)
         {
 			bw.Write(Constructor);
-            bw.Write(id);
+            ComputeFlags();
+bw.Write(flags);
+
+bw.Write(id);
 bw.Write(access_hash);
 bw.Write(date);
 ObjectUtils.SerializeObject(sizes,bw);

TeleSharp.TL/TL/TLSendMessageGamePlayAction.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(-580219064)]
+    public class TLSendMessageGamePlayAction : TLAbsSendMessageAction
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -580219064;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/TLStickerSet.cs

@@ -20,8 +20,9 @@ namespace TeleSharp.TL
 
              public int flags {get;set;}
      public bool installed {get;set;}
-     public bool disabled {get;set;}
+     public bool archived {get;set;}
      public bool official {get;set;}
+     public bool masks {get;set;}
      public long id {get;set;}
      public long access_hash {get;set;}
      public string title {get;set;}
@@ -34,8 +35,9 @@ namespace TeleSharp.TL
 		{
 			flags = 0;
 flags = installed ? (flags | 1) : (flags & ~1);
-flags = disabled ? (flags | 2) : (flags & ~2);
+flags = archived ? (flags | 2) : (flags & ~2);
 flags = official ? (flags | 4) : (flags & ~4);
+flags = masks ? (flags | 8) : (flags & ~8);
 
 		}
 
@@ -43,8 +45,9 @@ flags = official ? (flags | 4) : (flags & ~4);
         {
             flags = br.ReadInt32();
 installed = (flags & 1) != 0;
-disabled = (flags & 2) != 0;
+archived = (flags & 2) != 0;
 official = (flags & 4) != 0;
+masks = (flags & 8) != 0;
 id = br.ReadInt64();
 access_hash = br.ReadInt64();
 title = StringUtil.Deserialize(br);
@@ -62,6 +65,7 @@ bw.Write(flags);
 
 
 
+
 bw.Write(id);
 bw.Write(access_hash);
 StringUtil.Serialize(title,bw);

TeleSharp.TL/TL/TLStickerSetCovered.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(1678812626)]
+    public class TLStickerSetCovered : TLAbsStickerSetCovered
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1678812626;
+            }
+        }
+
+             public TLStickerSet @set {get;set;}
+     public TLAbsDocument cover {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            @set = (TLStickerSet)ObjectUtils.DeserializeObject(br);
+cover = (TLAbsDocument)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(@set,bw);
+ObjectUtils.SerializeObject(cover,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLStickerSetMultiCovered.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(872932635)]
+    public class TLStickerSetMultiCovered : TLAbsStickerSetCovered
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 872932635;
+            }
+        }
+
+             public TLStickerSet @set {get;set;}
+     public TLVector<TLAbsDocument> covers {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            @set = (TLStickerSet)ObjectUtils.DeserializeObject(br);
+covers = (TLVector<TLAbsDocument>)ObjectUtils.DeserializeVector<TLAbsDocument>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(@set,bw);
+ObjectUtils.SerializeObject(covers,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/TLUpdateBotCallbackQuery.cs

@@ -7,47 +7,70 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(-1500747636)]
+	[TLObject(-415938591)]
     public class TLUpdateBotCallbackQuery : TLAbsUpdate
     {
         public override int Constructor
         {
             get
             {
-                return -1500747636;
+                return -415938591;
             }
         }
 
-             public long query_id {get;set;}
+             public int flags {get;set;}
+     public long query_id {get;set;}
      public int user_id {get;set;}
      public TLAbsPeer peer {get;set;}
      public int msg_id {get;set;}
+     public long chat_instance {get;set;}
      public byte[] data {get;set;}
+     public string game_short_name {get;set;}
 
 
 		public void ComputeFlags()
 		{
-			
+			flags = 0;
+flags = data != null ? (flags | 1) : (flags & ~1);
+flags = game_short_name != null ? (flags | 2) : (flags & ~2);
+
 		}
 
         public override void DeserializeBody(BinaryReader br)
         {
-            query_id = br.ReadInt64();
+            flags = br.ReadInt32();
+query_id = br.ReadInt64();
 user_id = br.ReadInt32();
 peer = (TLAbsPeer)ObjectUtils.DeserializeObject(br);
 msg_id = br.ReadInt32();
+chat_instance = br.ReadInt64();
+if ((flags & 1) != 0)
 data = BytesUtil.Deserialize(br);
+else
+data = null;
+
+if ((flags & 2) != 0)
+game_short_name = StringUtil.Deserialize(br);
+else
+game_short_name = null;
+
 
         }
 
         public override void SerializeBody(BinaryWriter bw)
         {
 			bw.Write(Constructor);
-            bw.Write(query_id);
+            ComputeFlags();
+bw.Write(flags);
+bw.Write(query_id);
 bw.Write(user_id);
 ObjectUtils.SerializeObject(peer,bw);
 bw.Write(msg_id);
+bw.Write(chat_instance);
+if ((flags & 1) != 0)
 BytesUtil.Serialize(data,bw);
+if ((flags & 2) != 0)
+StringUtil.Serialize(game_short_name,bw);
 
         }
     }

TeleSharp.TL/TL/TLUpdateConfig.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(-1574314746)]
+    public class TLUpdateConfig : TLAbsUpdate
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1574314746;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/TLUpdateInlineBotCallbackQuery.cs

@@ -7,44 +7,67 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(750622127)]
+	[TLObject(-103646630)]
     public class TLUpdateInlineBotCallbackQuery : TLAbsUpdate
     {
         public override int Constructor
         {
             get
             {
-                return 750622127;
+                return -103646630;
             }
         }
 
-             public long query_id {get;set;}
+             public int flags {get;set;}
+     public long query_id {get;set;}
      public int user_id {get;set;}
      public TLInputBotInlineMessageID msg_id {get;set;}
+     public long chat_instance {get;set;}
      public byte[] data {get;set;}
+     public string game_short_name {get;set;}
 
 
 		public void ComputeFlags()
 		{
-			
+			flags = 0;
+flags = data != null ? (flags | 1) : (flags & ~1);
+flags = game_short_name != null ? (flags | 2) : (flags & ~2);
+
 		}
 
         public override void DeserializeBody(BinaryReader br)
         {
-            query_id = br.ReadInt64();
+            flags = br.ReadInt32();
+query_id = br.ReadInt64();
 user_id = br.ReadInt32();
 msg_id = (TLInputBotInlineMessageID)ObjectUtils.DeserializeObject(br);
+chat_instance = br.ReadInt64();
+if ((flags & 1) != 0)
 data = BytesUtil.Deserialize(br);
+else
+data = null;
+
+if ((flags & 2) != 0)
+game_short_name = StringUtil.Deserialize(br);
+else
+game_short_name = null;
+
 
         }
 
         public override void SerializeBody(BinaryWriter bw)
         {
 			bw.Write(Constructor);
-            bw.Write(query_id);
+            ComputeFlags();
+bw.Write(flags);
+bw.Write(query_id);
 bw.Write(user_id);
 ObjectUtils.SerializeObject(msg_id,bw);
+bw.Write(chat_instance);
+if ((flags & 1) != 0)
 BytesUtil.Serialize(data,bw);
+if ((flags & 2) != 0)
+StringUtil.Serialize(game_short_name,bw);
 
         }
     }

TeleSharp.TL/TL/TLUpdatePtsChanged.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(861169551)]
+    public class TLUpdatePtsChanged : TLAbsUpdate
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 861169551;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/TLUpdateReadFeaturedStickers.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(1461528386)]
+    public class TLUpdateReadFeaturedStickers : TLAbsUpdate
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1461528386;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/TLUpdateRecentStickers.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL
+{
+	[TLObject(-1706939360)]
+    public class TLUpdateRecentStickers : TLAbsUpdate
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1706939360;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/TLUpdateStickerSetsOrder.cs

@@ -7,35 +7,44 @@ using System.Threading.Tasks;
 using TeleSharp.TL;
 namespace TeleSharp.TL
 {
-	[TLObject(-253774767)]
+	[TLObject(196268545)]
     public class TLUpdateStickerSetsOrder : TLAbsUpdate
     {
         public override int Constructor
         {
             get
             {
-                return -253774767;
+                return 196268545;
             }
         }
 
-             public TLVector<long> order {get;set;}
+             public int flags {get;set;}
+     public bool masks {get;set;}
+     public TLVector<long> order {get;set;}
 
 
 		public void ComputeFlags()
 		{
-			
+			flags = 0;
+flags = masks ? (flags | 1) : (flags & ~1);
+
 		}
 
         public override void DeserializeBody(BinaryReader br)
         {
-            order = (TLVector<long>)ObjectUtils.DeserializeVector<long>(br);
+            flags = br.ReadInt32();
+masks = (flags & 1) != 0;
+order = (TLVector<long>)ObjectUtils.DeserializeVector<long>(br);
 
         }
 
         public override void SerializeBody(BinaryWriter bw)
         {
 			bw.Write(Constructor);
-            ObjectUtils.SerializeObject(order,bw);
+            ComputeFlags();
+bw.Write(flags);
+
+ObjectUtils.SerializeObject(order,bw);
 
         }
     }