public async Task Placelist(IUserMessage imsg)
            {
                var channel = (ITextChannel)imsg.Channel;

                await channel.SendMessageAsync(typesStr)
                             .ConfigureAwait(false);
            }

 public async Task Flip(IUserMessage imsg, int count = 1)
 {
     var channel = (ITextChannel)imsg.Channel;
     if (count == 1)
     {
         if (rng.Next(0, 2) == 1)
             await channel.SendFileAsync(headsPath, $"{imsg.Author.Mention} rolled " + Format.Code("Heads") + ".").ConfigureAwait(false);
         else
             await channel.SendFileAsync(tailsPath, $"{imsg.Author.Mention} rolled " + Format.Code("Tails") + ".").ConfigureAwait(false);
         return;
     }
     if (count > 10 || count < 1)
     {
         await channel.SendMessageAsync("`Invalid number specified. You can flip 1 to 10 coins.`");
         return;
     }
     var imgs = new Image[count];
     for (var i = 0; i < count; i++)
     {
         imgs[i] = rng.Next(0, 10) < 5 ?
                     new Image(File.OpenRead(headsPath)) :
                     new Image(File.OpenRead(tailsPath));
     }
     await channel.SendFileAsync(imgs.Merge().ToStream(), $"{count} coins.png").ConfigureAwait(false);
 }

            public async Task Draw(IUserMessage msg, int num = 1)
            {
                var channel = (ITextChannel)msg.Channel;
                var cards = AllDecks.GetOrAdd(channel.Guild, (s) => new Cards());
                var images = new List<Image>();
                var cardObjects = new List<Cards.Card>();
                if (num > 5) num = 5;
                for (var i = 0; i < num; i++)
                {
                    if (cards.CardPool.Count == 0 && i != 0)
                    {
                        try { await channel.SendMessageAsync("No more cards in a deck.").ConfigureAwait(false); } catch (Exception ex) { _log.Warn(ex); }
                        break;
                    }
                    var currentCard = cards.DrawACard();
                    cardObjects.Add(currentCard);
                    using (var stream = File.OpenRead(Path.Combine(cardsPath, currentCard.ToString().ToLowerInvariant()+ ".jpg").Replace(' ','_')))
                        images.Add(new Image(stream));
                }
                MemoryStream bitmapStream = new MemoryStream();
                images.Merge().SaveAsPng(bitmapStream);
                bitmapStream.Position = 0;
                //todo CARD NAMES?
                var toSend = $"{msg.Author.Mention}";
                if (cardObjects.Count == 5)
                    toSend += $" drew `{Cards.GetHandValue(cardObjects)}`";

                await channel.SendFileAsync(bitmapStream, images.Count + " cards.jpg", toSend).ConfigureAwait(false);
            }

 public async Task InRole(IUserMessage umsg, [Remainder] string roles)
 {
     if (string.IsNullOrWhiteSpace(roles))
         return;
     var channel = (ITextChannel)umsg.Channel;
     var arg = roles.Split(',').Select(r => r.Trim().ToUpperInvariant());
     string send = _l["ℹ️ **Here is a list of users in a specfic role:**"];
     foreach (var roleStr in arg.Where(str => !string.IsNullOrWhiteSpace(str) && str != "@EVERYONE" && str != "EVERYONE"))
     {
         var role = channel.Guild.Roles.Where(r => r.Name.ToUpperInvariant() == roleStr).FirstOrDefault();
         if (role == null) continue;
         send += $"```css\n[{role.Name}]\n";
         send += string.Join(", ", channel.Guild.GetUsers().Where(u => u.Roles.Contains(role)).Select(u => u.ToString()));
         send += $"\n```";
     }
     var usr = umsg.Author as IGuildUser;
     while (send.Length > 2000)
     {
         if (!usr.GetPermissions(channel).ManageMessages)
         {
             await channel.SendMessageAsync($"⚠️ {usr.Mention} **you are not allowed to use this command on roles with a lot of users in them to prevent abuse.**").ConfigureAwait(false);
             return;
         }
         var curstr = send.Substring(0, 2000);
         await channel.SendMessageAsync(curstr.Substring(0,
                 curstr.LastIndexOf(", ", StringComparison.Ordinal) + 1)).ConfigureAwait(false);
         send = curstr.Substring(curstr.LastIndexOf(", ", StringComparison.Ordinal) + 1) +
                send.Substring(2000);
     }
     await channel.SendMessageAsync(send).ConfigureAwait(false);
 }

 public override Task<TypeReaderResult> Read(IUserMessage context, string input)
 {
     input = input.ToUpperInvariant();
     switch (input)
     {
         case "1":
         case "T":
         case "TRUE":
         case "ENABLE":
         case "ENABLED":
         case "ALLOW":
         case "PERMIT":
         case "UNBAN":
             return Task.FromResult(TypeReaderResult.FromSuccess(PermissionAction.Enable));
         case "0":
         case "F":
         case "FALSE":
         case "DENY":
         case "DISABLE":
         case "DISABLED":
         case "DISALLOW":
         case "BAN":
             return Task.FromResult(TypeReaderResult.FromSuccess(PermissionAction.Disable));
         default:
             return Task.FromResult(TypeReaderResult.FromError(CommandError.ParseFailed, "Did not receive a valid boolean value"));
     }
 }

        public async Task ServerInfo(IUserMessage msg, string guild = null)
        {
            var channel = (ITextChannel)msg.Channel;
            guild = guild?.ToUpperInvariant();
            IGuild server;
            if (guild == null)
                server = channel.Guild;
            else
                server = _client.GetGuilds().Where(g => g.Name.ToUpperInvariant() == guild.ToUpperInvariant()).FirstOrDefault();
            if (server == null)
                return;

            var createdAt = new DateTime(2015, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(server.Id >> 22);
            var sb = new StringBuilder();
            var users = await server.GetUsersAsync();
            sb.AppendLine([email protected]"__`Name:`__ **{server.Name}**
__`Owner:`__ **{await server.GetUserAsync(server.OwnerId)}**
__`ID:`__ **{server.Id}**
__`Icon URL:`__ { server.IconUrl}
__`TextChannels:`__ **{(await server.GetTextChannelsAsync()).Count()}** `VoiceChannels:` **{(await server.GetVoiceChannelsAsync()).Count()}**
__`Members:`__ **{users.Count}** `-` {users.Count(u => u.Status == UserStatus.Online)}