Allow staff-only logging of commands when non-staff logs are disabled.

joker-119 · joker-119 · commit e208977ff804 · 2022-10-20T00:53:08.000-07:00
Remove redacted userids from Hurting &amp; Dying events for staff-only logs.
diff --git a/DiscordIntegration.Bot/Bot.cs b/DiscordIntegration.Bot/Bot.cs
@@ -102,16 +102,21 @@ private async void OnReceived(object? sender, ReceivedFullEventArgs ev)
             switch (command.Action)
             {
                 case ActionType.Log:
+                    Log.Debug(ServerNumber, nameof(OnReceived), $"{Enum.TryParse(command.Parameters[0].ToString(), true, out ChannelType _)}");
                     if (Enum.TryParse(command.Parameters[0].ToString(), true, out ChannelType type))
                     {
                         foreach (LogChannel channel in Program.Config.Channels[ServerNumber].Logs[type])
                         {
+                            Log.Debug(ServerNumber, nameof(OnReceived), "Adding message to queue..");
                             if (!Messages.ContainsKey(channel))
                                 Messages.Add(channel, string.Empty);
                             Messages[channel] += $"[{DateTime.Now}] {command.Parameters[1]}\n";
                         }
+
+                        break;
                     }
 
+                    Log.Debug(ServerNumber, nameof(OnReceived), "Failed to add message to queue.");
                     break;
                 case ActionType.SendMessage:
                     if (ulong.TryParse(command.Parameters[0].ToString(), out ulong chanId))
@@ -191,6 +196,7 @@ private async Task DequeueMessages()
     {
         for (;;)
         {
+            Log.Debug(ServerNumber, nameof(DequeueMessages), "Dequeue loop");
             List<KeyValuePair<LogChannel, string>> toSend = new();
             lock (Messages)
             {
@@ -229,17 +235,21 @@ private async Task DequeueMessages()
                         Messages.Add(message.Key, message.Value.Substring(msg.Length));
                     }
                     else
+                    {
+                        Log.Debug(ServerNumber, nameof(DequeueMessages), $"Sending message to {message.Key.Id}: {message.Key.LogType} -- {message.Value}");
                         switch (message.Key.LogType)
                         {
                             case LogType.Embed:
-                                _ = Guild.GetTextChannel(message.Key.Id).SendMessageAsync(embed: await EmbedBuilderService.CreateBasicEmbed($"Server {ServerNumber} Logs", message.Value, Color.Green));
+                                await Guild.GetTextChannel(message.Key.Id).SendMessageAsync(embed: await EmbedBuilderService.CreateBasicEmbed($"Server {ServerNumber} Logs", message.Value, Color.Green));
                                 break;
                             case LogType.Text:
-                                _ = Guild.GetTextChannel(message.Key.Id).SendMessageAsync($"[{ServerNumber}]: {message.Value}");
+                                await Guild.GetTextChannel(message.Key.Id).SendMessageAsync($"[{ServerNumber}]: {message.Value}");
                                 break;
                             default:
                                 throw new ArgumentOutOfRangeException();
                         }
+                        Log.Debug(ServerNumber, nameof(DequeueMessages), "Message sent.");
+                    }
                 }
                 catch (Exception e)
                 {
@@ -248,6 +258,7 @@ private async Task DequeueMessages()
                 }
             }
 
+            Log.Debug(ServerNumber, nameof(DequeueMessages), $"Waiting {Program.Config.MessageDelay} ms");
             await Task.Delay(Program.Config.MessageDelay);
         }
     }
diff --git a/DiscordIntegration/DiscordIntegration.csproj b/DiscordIntegration/DiscordIntegration.csproj
@@ -3,8 +3,8 @@
   <PropertyGroup>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>annotations</Nullable>
-    <AssemblyVersion>6.0.5</AssemblyVersion>
-    <FileVersion>6.0.5</FileVersion>
+    <AssemblyVersion>6.0.6</AssemblyVersion>
+    <FileVersion>6.0.6</FileVersion>
     <LangVersion>10</LangVersion>
     <TargetFramework>net472</TargetFramework>
   </PropertyGroup>
diff --git a/DiscordIntegration/Events/PlayerHandler.cs b/DiscordIntegration/Events/PlayerHandler.cs
@@ -218,7 +218,7 @@ public async void OnHurting(HurtingEventArgs ev)
                 await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.GameEvents, string.Format(Language.HasDamagedForWith, ev.Attacker != null ? ev.Attacker.Nickname : "Server", Instance.Config.ShouldLogUserIds ? ev.Attacker != null ? ev.Attacker.UserId : string.Empty : Language.Redacted, ev.Attacker?.Role ?? RoleType.None, ev.Target.Nickname, Instance.Config.ShouldLogUserIds ? ev.Target.UserId : Language.Redacted, ev.Target.Role, ev.Amount, ev.Handler.Type))).ConfigureAwait(false);
 
             if (Instance.Config.StaffOnlyEventsToLog.HurtingPlayer && ev.Target != null && (ev.Attacker == null || !Instance.Config.ShouldLogFriendlyFireDamageOnly || ev.Attacker.Role.Side == ev.Target.Role.Side) && !Instance.Config.BlacklistedDamageTypes.Contains(ev.Handler.Type) && (!Instance.Config.OnlyLogPlayerDamage || ev.Attacker != null))
-                await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.StaffCopy, string.Format(Language.HasDamagedForWith, ev.Attacker != null ? ev.Attacker.Nickname : "Server", Instance.Config.ShouldLogUserIds ? ev.Attacker != null ? ev.Attacker.UserId : string.Empty : Language.Redacted, ev.Attacker?.Role ?? RoleType.None, ev.Target.Nickname, Instance.Config.ShouldLogUserIds ? ev.Target.UserId : Language.Redacted, ev.Target.Role, ev.Amount, ev.Handler.Type))).ConfigureAwait(false);
+                await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.StaffCopy, string.Format(Language.HasDamagedForWith, ev.Attacker != null ? ev.Attacker.Nickname : "Server", ev.Attacker != null ? ev.Attacker.UserId : string.Empty, ev.Attacker?.Role ?? RoleType.None, ev.Target.Nickname, ev.Target.UserId, ev.Target.Role, ev.Amount, ev.Handler.Type))).ConfigureAwait(false);
         }
 
         public async void OnDying(DyingEventArgs ev)
@@ -227,7 +227,7 @@ public async void OnDying(DyingEventArgs ev)
                 await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.GameEvents, string.Format(Language.HasKilledWith, ev.Killer != null ? ev.Killer.Nickname : "Server", Instance.Config.ShouldLogUserIds ? ev.Killer != null ? ev.Killer.UserId : string.Empty : Language.Redacted, ev.Killer?.Role ?? RoleType.None, ev.Target.Nickname, Instance.Config.ShouldLogUserIds ? ev.Target.UserId : Language.Redacted, ev.Target.Role, ev.Handler.Type))).ConfigureAwait(false);
 
             if (Instance.Config.StaffOnlyEventsToLog.PlayerDying && ev.Target != null && (ev.Killer == null || !Instance.Config.ShouldLogFriendlyFireKillsOnly || ev.Killer.Role.Side == ev.Target.Role.Side))
-                await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.StaffCopy, string.Format(Language.HasKilledWith, ev.Killer != null ? ev.Killer.Nickname : "Server", Instance.Config.ShouldLogUserIds ? ev.Killer != null ? ev.Killer.UserId : string.Empty : Language.Redacted, ev.Killer?.Role ?? RoleType.None, ev.Target.Nickname, Instance.Config.ShouldLogUserIds ? ev.Target.UserId : Language.Redacted, ev.Target.Role, ev.Handler.Type))).ConfigureAwait(false);
+                await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.StaffCopy, string.Format(Language.HasKilledWith, ev.Killer != null ? ev.Killer.Nickname : "Server", ev.Killer != null ? ev.Killer.UserId : string.Empty, ev.Killer?.Role ?? RoleType.None, ev.Target.Nickname, ev.Target.UserId, ev.Target.Role, ev.Handler.Type))).ConfigureAwait(false);
         }
 
         public async void OnThrowingGrenade(ThrowingItemEventArgs ev)
@@ -318,7 +318,7 @@ public async void OnChangingGroup(ChangingGroupEventArgs ev)
         {
             if (ev.Player != null && Instance.Config.EventsToLog.ChangingPlayerGroup && (!ev.Player.DoNotTrack || !Instance.Config.ShouldRespectDoNotTrack))
                 await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.GameEvents, string.Format(Language.GroupSet, ev.Player.Nickname, Instance.Config.ShouldLogUserIds ? ev.Player.UserId : Language.Redacted, ev.Player.Role, ev.NewGroup?.BadgeText ?? Language.None, ev.NewGroup?.BadgeColor ?? Language.None))).ConfigureAwait(false);
-            if (Instance.Config.StaffOnlyEventsToLog.ChangingPlayerGroup)
+            if (ev.Player != null && Instance.Config.StaffOnlyEventsToLog.ChangingPlayerGroup)
                 await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.StaffCopy, string.Format(Language.GroupSet, ev.Player.Nickname, ev.Player.UserId, ev.Player.Role, ev.NewGroup?.BadgeText ?? Language.None, ev.NewGroup?.BadgeColor ?? Language.None))).ConfigureAwait(false);
         }
     }
diff --git a/DiscordIntegration/Patches/ClientCommandLogging.cs b/DiscordIntegration/Patches/ClientCommandLogging.cs
@@ -53,8 +53,9 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
         private static void LogCommand(string query, CommandSender sender)
         {
-            if (!DiscordIntegration.Instance.Config.EventsToLog.SendingConsoleCommands)
+            if (!DiscordIntegration.Instance.Config.EventsToLog.SendingConsoleCommands && !DiscordIntegration.Instance.Config.StaffOnlyEventsToLog.SendingConsoleCommands)
                 return;
+
             string[] args = query.Trim().Split(QueryProcessor.SpaceArray, 512, StringSplitOptions.RemoveEmptyEntries);
             if (args[0].StartsWith("$"))
                 return;
@@ -64,7 +65,8 @@ private static void LogCommand(string query, CommandSender sender)
                 : Server.Host;
             if (player == null || (!string.IsNullOrEmpty(player.UserId) && DiscordIntegration.Instance.Config.TrustedAdmins.Contains(player.UserId)))
                 return;
-            _ = DiscordIntegration.Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.Command, string.Format(DiscordIntegration.Language.UsedCommand, sender.Nickname, sender.SenderId ?? DiscordIntegration.Language.DedicatedServer, player.Role, args[0], string.Join(" ", args.Where(a => a != args[0])))));
+            if (DiscordIntegration.Instance.Config.EventsToLog.SendingConsoleCommands)
+                _ = DiscordIntegration.Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.Command, string.Format(DiscordIntegration.Language.UsedCommand, sender.Nickname, sender.SenderId ?? DiscordIntegration.Language.DedicatedServer, player.Role, args[0], string.Join(" ", args.Where(a => a != args[0])))));
             if (DiscordIntegration.Instance.Config.StaffOnlyEventsToLog.SendingConsoleCommands)
                 _ = DiscordIntegration.Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.StaffCopy, string.Format(DiscordIntegration.Language.UsedCommand, sender.Nickname, sender.SenderId ?? DiscordIntegration.Language.DedicatedServer, player.Role, args[0], string.Join(" ", args.Where(a => a != args[0])))));
         }
diff --git a/DiscordIntegration/Patches/CommandLogging.cs b/DiscordIntegration/Patches/CommandLogging.cs
@@ -49,8 +49,9 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
         private static void LogCommand(string query, CommandSender sender)
         {
-            if (!DiscordIntegration.Instance.Config.EventsToLog.SendingRemoteAdminCommands)
+            if (!DiscordIntegration.Instance.Config.EventsToLog.SendingRemoteAdminCommands && !DiscordIntegration.Instance.Config.StaffOnlyEventsToLog.SendingRemoteAdminCommands)
                 return;
+
             string[] args = query.Trim().Split(QueryProcessor.SpaceArray, 512, StringSplitOptions.RemoveEmptyEntries);
             if (args[0].StartsWith("$"))
                 return;
@@ -60,7 +61,8 @@ private static void LogCommand(string query, CommandSender sender)
                 : Server.Host;
             if (player == null || (!string.IsNullOrEmpty(player.UserId) && DiscordIntegration.Instance.Config.TrustedAdmins.Contains(player.UserId)))
                 return;
-            _ = DiscordIntegration.Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.Command, string.Format(DiscordIntegration.Language.UsedCommand, sender.Nickname, sender.SenderId ?? DiscordIntegration.Language.DedicatedServer, player.Role, args[0], string.Join(" ", args.Where(a => a != args[0])))));
+            if (DiscordIntegration.Instance.Config.EventsToLog.SendingRemoteAdminCommands)
+                _ = DiscordIntegration.Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.Command, string.Format(DiscordIntegration.Language.UsedCommand, sender.Nickname, sender.SenderId ?? DiscordIntegration.Language.DedicatedServer, player.Role, args[0], string.Join(" ", args.Where(a => a != args[0])))));
             if (DiscordIntegration.Instance.Config.StaffOnlyEventsToLog.SendingRemoteAdminCommands)
                 _ = DiscordIntegration.Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.StaffCopy, string.Format(DiscordIntegration.Language.UsedCommand, sender.Nickname, sender.SenderId ?? DiscordIntegration.Language.DedicatedServer, player.Role, args[0], string.Join(" ", args.Where(a => a != args[0])))));
         }

Original file line number	Diff line number	Diff line change
`@@ -102,16 +102,21 @@ private async void OnReceived(object? sender, ReceivedFullEventArgs ev)`
`102`	`102`	`switch (command.Action)`
`103`	`103`	`{`
`104`	`104`	`case ActionType.Log:`
	`105`	`+ Log.Debug(ServerNumber, nameof(OnReceived), $"{Enum.TryParse(command.Parameters[0].ToString(), true, out ChannelType _)}");`
`105`	`106`	`if (Enum.TryParse(command.Parameters[0].ToString(), true, out ChannelType type))`
`106`	`107`	`{`
`107`	`108`	`foreach (LogChannel channel in Program.Config.Channels[ServerNumber].Logs[type])`
`108`	`109`	`{`
	`110`	`+ Log.Debug(ServerNumber, nameof(OnReceived), "Adding message to queue..");`
`109`	`111`	`if (!Messages.ContainsKey(channel))`
`110`	`112`	`Messages.Add(channel, string.Empty);`
`111`	`113`	`Messages[channel] += $"[{DateTime.Now}] {command.Parameters[1]}\n";`
`112`	`114`	`}`
	`115`	`+`
	`116`	`+ break;`
`113`	`117`	`}`
`114`	`118`
	`119`	`+ Log.Debug(ServerNumber, nameof(OnReceived), "Failed to add message to queue.");`
`115`	`120`	`break;`
`116`	`121`	`case ActionType.SendMessage:`
`117`	`122`	`if (ulong.TryParse(command.Parameters[0].ToString(), out ulong chanId))`
`@@ -191,6 +196,7 @@ private async Task DequeueMessages()`
`191`	`196`	`{`
`192`	`197`	`for (;;)`
`193`	`198`	`{`
	`199`	`+ Log.Debug(ServerNumber, nameof(DequeueMessages), "Dequeue loop");`
`194`	`200`	`List<KeyValuePair<LogChannel, string>> toSend = new();`
`195`	`201`	`lock (Messages)`
`196`	`202`	`{`
`@@ -229,17 +235,21 @@ private async Task DequeueMessages()`
`229`	`235`	`Messages.Add(message.Key, message.Value.Substring(msg.Length));`
`230`	`236`	`}`
`231`	`237`	`else`
	`238`	`+ {`
	`239`	`+ Log.Debug(ServerNumber, nameof(DequeueMessages), $"Sending message to {message.Key.Id}: {message.Key.LogType} -- {message.Value}");`
`232`	`240`	`switch (message.Key.LogType)`
`233`	`241`	`{`
`234`	`242`	`case LogType.Embed:`
`235`		`- _ = Guild.GetTextChannel(message.Key.Id).SendMessageAsync(embed: await EmbedBuilderService.CreateBasicEmbed($"Server {ServerNumber} Logs", message.Value, Color.Green));`
	`243`	`+ await Guild.GetTextChannel(message.Key.Id).SendMessageAsync(embed: await EmbedBuilderService.CreateBasicEmbed($"Server {ServerNumber} Logs", message.Value, Color.Green));`
`236`	`244`	`break;`
`237`	`245`	`case LogType.Text:`
`238`		`- _ = Guild.GetTextChannel(message.Key.Id).SendMessageAsync($"[{ServerNumber}]: {message.Value}");`
	`246`	`+ await Guild.GetTextChannel(message.Key.Id).SendMessageAsync($"[{ServerNumber}]: {message.Value}");`
`239`	`247`	`break;`
`240`	`248`	`default:`
`241`	`249`	`throw new ArgumentOutOfRangeException();`
`242`	`250`	`}`
	`251`	`+ Log.Debug(ServerNumber, nameof(DequeueMessages), "Message sent.");`
	`252`	`+ }`
`243`	`253`	`}`
`244`	`254`	`catch (Exception e)`
`245`	`255`	`{`
`@@ -248,6 +258,7 @@ private async Task DequeueMessages()`
`248`	`258`	`}`
`249`	`259`	`}`
`250`	`260`
	`261`	`+ Log.Debug(ServerNumber, nameof(DequeueMessages), $"Waiting {Program.Config.MessageDelay} ms");`
`251`	`262`	`await Task.Delay(Program.Config.MessageDelay);`
`252`	`263`	`}`
`253`	`264`	`}`
Original file line number	Diff line number	Diff line change
`@@ -218,7 +218,7 @@ public async void OnHurting(HurtingEventArgs ev)`
`218`	`218`	`await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.GameEvents, string.Format(Language.HasDamagedForWith, ev.Attacker != null ? ev.Attacker.Nickname : "Server", Instance.Config.ShouldLogUserIds ? ev.Attacker != null ? ev.Attacker.UserId : string.Empty : Language.Redacted, ev.Attacker?.Role ?? RoleType.None, ev.Target.Nickname, Instance.Config.ShouldLogUserIds ? ev.Target.UserId : Language.Redacted, ev.Target.Role, ev.Amount, ev.Handler.Type))).ConfigureAwait(false);`
`219`	`219`
`220`	`220`	`if (Instance.Config.StaffOnlyEventsToLog.HurtingPlayer && ev.Target != null && (ev.Attacker == null \|\| !Instance.Config.ShouldLogFriendlyFireDamageOnly \|\| ev.Attacker.Role.Side == ev.Target.Role.Side) && !Instance.Config.BlacklistedDamageTypes.Contains(ev.Handler.Type) && (!Instance.Config.OnlyLogPlayerDamage \|\| ev.Attacker != null))`
`221`		- await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.StaffCopy, string.Format(Language.HasDamagedForWith, ev.Attacker != null ? ev.Attacker.Nickname : "Server", Instance.Config.ShouldLogUserIds ? ev.Attacker != null ? ev.Attacker.UserId : string.Empty : Language.Redacted, ev.Attacker?.Role ?? RoleType.None, ev.Target.Nickname, Instance.Config.ShouldLogUserIds ? ev.Target.UserId : Language.Redacted, ev.Target.Role, ev.Amount, ev.Handler.Type))).ConfigureAwait(false);
	`221`	`+ await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.StaffCopy, string.Format(Language.HasDamagedForWith, ev.Attacker != null ? ev.Attacker.Nickname : "Server", ev.Attacker != null ? ev.Attacker.UserId : string.Empty, ev.Attacker?.Role ?? RoleType.None, ev.Target.Nickname, ev.Target.UserId, ev.Target.Role, ev.Amount, ev.Handler.Type))).ConfigureAwait(false);`
`222`	`222`	`}`
`223`	`223`
`224`	`224`	`public async void OnDying(DyingEventArgs ev)`
`@@ -227,7 +227,7 @@ public async void OnDying(DyingEventArgs ev)`
`227`	`227`	`await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.GameEvents, string.Format(Language.HasKilledWith, ev.Killer != null ? ev.Killer.Nickname : "Server", Instance.Config.ShouldLogUserIds ? ev.Killer != null ? ev.Killer.UserId : string.Empty : Language.Redacted, ev.Killer?.Role ?? RoleType.None, ev.Target.Nickname, Instance.Config.ShouldLogUserIds ? ev.Target.UserId : Language.Redacted, ev.Target.Role, ev.Handler.Type))).ConfigureAwait(false);`
`228`	`228`
`229`	`229`	`if (Instance.Config.StaffOnlyEventsToLog.PlayerDying && ev.Target != null && (ev.Killer == null \|\| !Instance.Config.ShouldLogFriendlyFireKillsOnly \|\| ev.Killer.Role.Side == ev.Target.Role.Side))`
`230`		`- await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.StaffCopy, string.Format(Language.HasKilledWith, ev.Killer != null ? ev.Killer.Nickname : "Server", Instance.Config.ShouldLogUserIds ? ev.Killer != null ? ev.Killer.UserId : string.Empty : Language.Redacted, ev.Killer?.Role ?? RoleType.None, ev.Target.Nickname, Instance.Config.ShouldLogUserIds ? ev.Target.UserId : Language.Redacted, ev.Target.Role, ev.Handler.Type))).ConfigureAwait(false);`
	`230`	`+ await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.StaffCopy, string.Format(Language.HasKilledWith, ev.Killer != null ? ev.Killer.Nickname : "Server", ev.Killer != null ? ev.Killer.UserId : string.Empty, ev.Killer?.Role ?? RoleType.None, ev.Target.Nickname, ev.Target.UserId, ev.Target.Role, ev.Handler.Type))).ConfigureAwait(false);`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`public async void OnThrowingGrenade(ThrowingItemEventArgs ev)`
`@@ -318,7 +318,7 @@ public async void OnChangingGroup(ChangingGroupEventArgs ev)`
`318`	`318`	`{`
`319`	`319`	`if (ev.Player != null && Instance.Config.EventsToLog.ChangingPlayerGroup && (!ev.Player.DoNotTrack \|\| !Instance.Config.ShouldRespectDoNotTrack))`
`320`	`320`	`await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.GameEvents, string.Format(Language.GroupSet, ev.Player.Nickname, Instance.Config.ShouldLogUserIds ? ev.Player.UserId : Language.Redacted, ev.Player.Role, ev.NewGroup?.BadgeText ?? Language.None, ev.NewGroup?.BadgeColor ?? Language.None))).ConfigureAwait(false);`
`321`		`- if (Instance.Config.StaffOnlyEventsToLog.ChangingPlayerGroup)`
	`321`	`+ if (ev.Player != null && Instance.Config.StaffOnlyEventsToLog.ChangingPlayerGroup)`
`322`	`322`	`await Network.SendAsync(new RemoteCommand(ActionType.Log, ChannelType.StaffCopy, string.Format(Language.GroupSet, ev.Player.Nickname, ev.Player.UserId, ev.Player.Role, ev.NewGroup?.BadgeText ?? Language.None, ev.NewGroup?.BadgeColor ?? Language.None))).ConfigureAwait(false);`
`323`	`323`	`}`
`324`	`324`	`}`