text: import discord
  import asyncio
  
  async def pager(entries, chunk: int):
      for x in range(0, len(entries), chunk):
          yield entries[x:x + chunk]
  
  class SimplePaginator:
  
      __slots__ = ('entries', 'extras', 'title', 'description', 'colour', 'footer', 'length', 'prepend', 'append',
                   'fmt', 'timeout', 'ordered', 'controls', 'controller', 'pages', 'current', 'previous', 'eof', 'base',
                   'names')
  
      def __init__(self, **kwargs):
          self.entries = kwargs.get('entries', None)
          self.extras = kwargs.get('extras', None)
  
          self.title = kwargs.get('title', None)
          self.description = kwargs.get('description', None)
          self.colour = kwargs.get('colour', 0xffd4d4)
          self.footer = kwargs.get('footer', None)
  
          self.length = kwargs.get('length', 10)
          self.prepend = kwargs.get('prepend', '')
          self.append = kwargs.get('append', '')
          self.fmt = kwargs.get('fmt', '')
          self.timeout = kwargs.get('timeout', 90)
          self.ordered = kwargs.get('ordered', False)
  
          self.controller = None
          self.pages = []
          self.names = []
          self.base = None
  
          self.current = 0
          self.previous = 0
          self.eof = 0
  
          self.controls = {'⏮': 0.0, '◀': -1, '⏹': 'stop', '\u274c': 'delete',
                           '▶': +1, '⏭': None }
  
      async def indexer(self, ctx, ctrl):
          if str(ctrl) in 'stopdelete':
              ctx.bot.loop.create_task(self.stop_controller(self.base,int(ctrl=="stop")))
          elif isinstance(ctrl, int):
              self.current += ctrl
              if self.current > self.eof or self.current < 0:
                  self.current -= ctrl
          else:
              self.current = int(ctrl)
  
      async def reaction_controller(self, ctx):
          bot = ctx.bot
          author = ctx.author
  
          self.base = await ctx.send(embed=self.pages[0])
  
          if len(self.pages) == 1:
              await self.base.add_reaction('⏹')
              await self.base.add_reaction('\u274c')
  
          else:
              for reaction in self.controls:
                  try:
                      await self.base.add_reaction(reaction)
                  except discord.HTTPException:
                      return
  
          def check(r, u):
              if str(r) not in self.controls.keys():
                  return False
              elif u.id == bot.user.id or r.message.id != self.base.id:
                  return False
              elif u.id != author.id:
                  return False
              return True
  
          while True:
              try:
                  react, user = await bot.wait_for('reaction_add', check=check, timeout=self.timeout)
              except asyncio.TimeoutError:
                  return ctx.bot.loop.create_task(self.stop_controller(self.base))
  
              control = self.controls.get(str(react))
  
              try:
                  await self.base.remove_reaction(react, user)
              except discord.HTTPException:
                  pass
  
              self.previous = self.current
              await self.indexer(ctx, control)
  
              if self.previous == self.current:
                  continue
  
              try:
                  await self.base.edit(embed=self.pages[self.current])
              except KeyError:
                  pass
  
      async def stop_controller(self, message, status=1):
          if status==1:
              try:
                  await message.clear_reactions()
              except discord.HTTPException:
                  pass
          elif status==0:
              try:
                  await message.delete()
              except discord.HTTPException:
                  pass
  
          try:
              self.controller.cancel()
          except Exception:
              pass
  
      def formmater(self, chunk):
          return '\n'.join(f'{self.prepend}{self.fmt}{value}{self.fmt[::-1]}{self.append}' for value in chunk)
  
      async def paginate(self, ctx):
          if self.extras:
              self.pages = [p for p in self.extras if isinstance(p, discord.Embed)]
  
          if self.entries:
              chunks = [c async for c in pager(self.entries, self.length)]
  
              for index, chunk in enumerate(chunks):
                  page = discord.Embed(title=f'{self.title} - {index + 1}/{len(chunks)}', color=self.colour)
                  page.description = self.formmater(chunk)
  
                  if self.footer:
                      page.set_footer(text=self.footer)
                  self.pages.append(page)
  
          if not self.pages:
              self.pages=[discord.Embed(title="Nothing Paginated",description="There is probably a blank output.",colour=discord.Colour.blurple())]
  
          self.eof = float(len(self.pages) - 1)
          self.controls['⏭'] = self.eof
          self.controller = ctx.bot.loop.create_task(self.reaction_controller(ctx))
  