01
 ░██▀█████    ░██▀████     ░▀███████     ░██▌  ░██     ░█▀████     ██     ░▀▀██████
  ░░░██       ░██░░░░█▌    ░██░░░░██     ░███ ░███    ░██░░░░██   ░██     ░██░░░░██
    ░██       ░██   ░█▌    ░██   ░██     ░██ ██░██    ░██   ░██   ░▓█     ░██   ░██
    ░██       ░██████▀     ░████████     ░██ 01░█▀    ░██   ░██   ░█▀     ░██████▀█
    ░█·       ░██   ▀█     ░▓█   ░██     ░▓█   ░██    ░▓█   ░██   ░█▓     ░▓█   ░██
    ░██       ░██   ░█     ░█▓   ░█▓     ░▒    ░█▓    ░░▓   ░▒▓   ░█▓     ░█▓   ░█▓
    ░▓▓       ░▓▓   ░▓▌    ░▓▓   ░▓▒     ░▓▒   ░▓▒    ░▒░   ░▓░   ░▒▒     ░▓▓   ░▓▒
    ░▒▓       ░▓    ░▓▌    ░▓▒   ░▓▓     ░░▒   ░░▓     ░▒████░    ░▓░     ░▓▒   ░░▓
    ░▓░       ░▒░   ░░▌    ░▒░                 ░▓▒                ░░▒     ░▒░   ░▓█
    ░▒▓       ░░▒          ░▒                  ░▒▓                ░▒░     ░▒·   ░▓▒
    ░▒·       ░▒           ░▒                  ░▓                 ░▒░     ░▒▓   ░░▓
    ░▒▒                                        ░▒░                  ░           ░▒·
    ░░░                                          ░                              ░░▒
    ·░░                                                                         ░░░
    ░░░                                                                         ░░░
    ░░░                               ^                                         ░░░
    ░░░                  _______     ^^^                                        ░░░
    ░░░                 |xxxxxxx|  _^^^^^_                                      ░░░
    ░░░                 |xxxxxxx| | [][]  |                                     ░░░
    ░░░              ______xxxxx| |[][][] |                                     ░░░
    ░░░             |++++++|xxxx| | [][][]|      HACKTOWN                       ░░░
    ░░░             |++++++|xxxx| |[][][] |       TR4M014 - trm 0x1             ░░░
    ░░░             |++++++|_________ [][]|                                     ░░░
    ░░░             |++++++|=|=|=|=|=| [] |                                     ░░░
    ░░░             |++++++|=|=|=|=|=|[][]|                                     ░░░
    ░░░  ___________|++HH++|  _HHHH__|   _________   _________  _________       ░░░
    ░░░           _______________   ______________      ______________          ░░░
    ·░░  __________________  ___________    __________________    ____________  ░░░
    ░░░                                                                         ░░░
    ░░░  |=-----------------------------------------------------------------=|  ·░░
    ░░░  |=-[ O Elixir do hacking "concorrente, distribuído e ofensivo"  ]--=|  ░░░
    ░░░  |=-----------------------------------------------------------------=|  ░░░
    ░░░  |=--------[ Rodrigo "N4s" Girorme <g1r0rm3 at gm41l com> ]---------=|  ░░░
    ░░░  |=------------------------------p0cl4bs----------------------------=|  ░░░
    ░░░                                                                         ·░░
    ░░░                                                                         ░░░
    ·░░  --[ Agenda                                                             ░░░
    ░░░                                                                         ░░░
    ·░░  - 0 -> Um curioso que gosta de hacking                                 ·░░
    ░░░  - 1 -> A ideia                                                         ░░░
    ░░░  - 2 -> As possibilidades                                               ░░░
    ░░░  - 3 -> Implementações                                                  ░░░
    ░░░  - 4 -> Agradecimento                                                   ░░░
    ░░░                                                                         ·░░
    ░░░  ### 0 - Um curioso que gosta de hacking                                ░░░
    ░░░                                                                         ░░░
    ░░░  Fala meu p0v0!                                                         ░░░
    ░░░                                                                         ░░░
    ░░░  Faz um tempo que não submeto algum conteúdo para a galera que gosta    ░░░
    ░░░  de hacking. O engraçado é que antes mesmo de começar esse artigo eu    ░░░
    ·░░  estava lendo a phrack #71... e cara, como é bom ver que o hacking ta   ░░░
    ░░░  vivo e te observando.                                                  ·░░
    ░░░  O hacking disperta vários sentimentos: a necessidade em aprender,      ░░░
    ·░░  entender como as coisas funcionam. O hacking te ensina a ser uma       ░░░
    ░░░  pessoa melhor. Nele pode se originar o professor, o hostil, o          ·░░
    ░░░  defensor de alguma ideia, não importa... o hacking te transforma.      ░░░
    ░░░                                                                         ░░░
    ░░░  Lembro de vários episódios de quando eu era um arruaceiro jovem e.     ░░░
    ░░░  ficava maluco para documentar, transformar ou simplesmente             ·░░
    ·░░  compartilhar nos canais da época o que tinha rolado em noite X ou Y.   ░░░
    ░░░  Uma "pesquisa" que deu certo, uma ferramenta nova que captura          ░░░
    ░░░  centenas, milhares de máquinas, de várias formas e de várias           ░░░
    ░░░  maneiras.                                                              ░░░
    ░░░                                                                         ░░░
    ░░░  Em algum momento do espaço tempo eu tive oportunidade conhecer várias  ░░░
    ░░░  pessoas que além de ótimos ser humanos nem sempre :D eram ótimos.      ·░░
    ░░░  programadores/hackers. Desenvolveram ferramentas excelentes, criaram   ░░░
    ·░░  artigos incríveis, ajudaram a comunidade e de forma direta ou          ░░░
    ·░░  indireta me motivaram muito a aprender o pouco que sei hoje.           ·░░
    ░░░                                                                         ░░░
    ░░░  Dessa galera obviamente impossível de citar todos, lembro bem de       ·░░
    ░░░  nomes como:                                                            ░░░
    ░░░  t4ph0d4, cool3r, kingcope, strauss, bsdaemon, burtay,                  ░░░
    ░░░  miyachung,mh4x0f /hc0d3r/joridos -> (até hoje eles ownam ta? Zuera!    ░░░
    ·░░  xD).                                                                   ·░░
    ░░░                                                                         ░░░
    ░░░  Não só eles mas vários outros dispertaram no eterno newbie aqui uma    ░░░
    ░░░  vontade muito grande em aprender, a programar e entender como as       ░░░
    ░░░  coisas funcionam, então nada mais junto do que essa menção honrosa.    ·░░
    ·░░                                                                         ░░░
    ░░░  > "It is not just about computers. It's about understanding how        ░░░
    ░░░  the world works. The world is made up of people. As much as machines   ░░░
    ░░░  keep society running, those machines are programmed by people--people  ░░░
    ░░░  with managers, spouses, and children; with wants, needs, and dreams.   ·░░
    ░░░  And it is about using that knowledge to bring about the change you     ·░░
    ·░░  want to see. That is what being a hacker is all about."                ░░░
    ░░░                                                                         ░░░
    ░░░  > "Não se trata apenas de computadores. É sobre entender como o mundo  ░░░
    ░░░  funciona. O mundo é feito de pessoas. Por mais que as máquinas         ░░░
    ░░░  mantenham a sociedade funcionando, essas máquinas são programadas por  ·░░
    ░░░  pessoas—pessoas com gerentes, cônjuges e filhos; com desejos,          ░░░
    ░░░  necessidades e sonhos. E se trata de usar esse conhecimento para       ░░░
    ░░░  promover a mudança que você quer ver.                                  ░░░
    ░░░  Isso é o que significa ser um hacker."                                 ░░░
    ░░░                                                                         ░░░
    ░░░  cts (@gf_256) # phrack #71                                             ░░░
    ░░░                                                                         ░░░
    ·░░  ### 1 - A ideia                                                        ░░░
    ░░░                                                                         ░░░
    ░░░  Talvez esse artigo não tenha o puro suco do hacking, popando shell a.  ░░░
    ░░░  torto e direito mas vai ajudar a aquecer os motores para outras        ·░░
    ░░░  publicações ou até quem sabe alguma talk por ai (h2hc ta chegando pra  ░░░
    ░░░  gente tomar umas). Aqui basicamente quero compartilhar algumas ideias  ·░░
    ·░░  e pesquisas que tenho feito no meio da programação distribuida e       ░░░
    ░░░  concorrente.                                                           ░░░
    ░░░                                                                         ░░░
    ░░░  Para dar um "background" e todos ficarem na mesma linha, nesse artigo  ░░░
    ░░░  a gente fala basicamente sobre elixir e erlang.                        ·░░
    ░░░                                                                         ░░░
    ░░░  Elixir                                                                 ░░░
    ·░░  > Linguagem que roda na vm do erlang, conhecida pela sua capacidade    ░░░
    ·░░  de construir aplicações resilientes em tempo real, além de ótimo       ░░░
    ░░░  suporte a concorrência e escalabilidade                                ░░░
    ·░░                                                                         ·░░
    ░░░  Erlang                                                                 ·░░
    ·░░  > O elixir funciona do jeito que funciona por causa do Erlang que foi. ·░░
    ░░░  criado para desenvolver sistemas de escala gigantesca (concorrência e. ░░░
    ░░░  escalabilidade nascem daqui), principalmente fazendo uso de técnicas   ░░░
    ░░░  para sistemas -> distribuídos!                                         ░░░
    ░░░                                                                         ░░░
    ░░░  Basicamente um canivete suíço quando o assunto é aplicação que         ░░░
    ·░░  precisa escalar e trabalhar com concorrêcia de forma violenta. E ca    ░░░
    ░░░  pra nós, essas carateristícas são essenciais para criar ótimas         ░░░
    ░░░  ferramentas para tramoiar por ai :)                                    ░░░
    ·░░                                                                         ░░░
    ░░░  ### 2 - As possibilidades                                              ·░░
    ░░░  A vm aqui (beam) lida eficientemente com concorrência, permitindo que  ░░░
    ·░░  múltiplos processos sejam criados de forma muito "barata".             ░░░
    ░░░  Algo parecido com que temos no golang (CSP):                           ·░░
    ·░░                                                                         ·░░
    ░░░    ...                                                                  ░░░
    ░░░    func main() {                                                        ░░░
    ░░░       go say("world") <----- say executa de forma concorrente           ░░░
    ░░░       say("hello")                                                      ░░░
    ░░░    }                                                                    ░░░
    ·░░                                                                         ·░░
    ░░░                                                                         ░░░
    ░░░  Pode ser feito no elixir da seguinte forma:                            ░░░
    ·░░                                                                         ░░░
    ░░░    ...                                                                  ░░░
    ░░░    def main() do                                                        ░░░
    ░░░        spawn(fn -> say("world") end) <---- say executa de forma         ░░░
    ·░░        say("hello")                        concorrente                  ░░░
    ░░░    end                                                                  ░░░
    ░░░                                                                         ░░░
    ░░░                                                                         ░░░
    ·░░  Essa syntax parecida com ruby é exatamente o que parece. Muita gente   ░░░
    ░░░  do core do ruby (alô msf) ajudou o elixir a nascer. Por ser uma        ░░░
    ░░░  linguagem funcional (aproveita as características como imutabilidade   ░░░
    ░░░  e outros dentro da concorrência) possui algumas declarações            ░░░
    ░░░  diferentes como with, pattern matching, etc.                           ░░░
    ░░░                                                                         ·░░
    ░░░  No geral o ponto forte da linguagem é o modelo de atores que é         ·░░
    ░░░  herdado do erlang:                                                     ░░░
    ░░░                                                                         ░░░
    ·░░                                                                         ░░░
    ░░░  Actor model                                                            ░░░
    ·░░  ~~~                                                                    ░░░
    ░░░  +-----------------------------------+                                  ░░░
    ░░░  |            Scheduler              |  ---> Lida com múltiplos         ·░░
    ░░░  +-----------------------------------+       processos                  ░░░
    ░░░           |                       |                                     ░░░
    ░░░           v                       v                                     ░░░
    ░░░  +-----------------------+ +------------------------+                   ░░░
    ░░░  |    Process 1          | |    Process 2           | ---> "Atores      ·░░
    ░░░  |-----------------------| |------------------------|   independentes"  ░░░
    ·░░  |  - Execução de código | |  - Execução de código  |                   ░░░
    ·░░  |  - Gerencia de estado | |  - Gerencia de estado  |                   ░░░
    ·░░  +-----------------------+ +------------------------+                   ░░░
    ░░░           |               /                                             ·░░
    ░░░           v               v                                             ░░░
    ░░░  +-----------------+ +-----------------+                                ░░░
    ░░░  |   Mailbox 1     | |   Mailbox 2     |  ---> Mensagens de cada        ·░░
    ░░░  +-----------------+ +-----------------+  processo (Pode ser uma        ░░░
    ░░░                           lista de urls,conteúdo de arquivo ou X)       ░░░
    ·░░                                                                         ░░░
    ░░░                                                                         ·░░
    ░░░  Vale mencionar também o conceito de "supervisão" para que um ou mais.  ░░░
    ░░░  processos sejam supervisionados de forma muito inteligente:            ░░░
    ·░░                                                                         ·░░
    ·░░                                                                         ░░░
    ░░░                                      APP                                ░░░
    ░░░                            +----------------------+                     ·░░
    ░░░                            |      Supervisor      |                     ░░░
    ·░░                            |----------------------|                     ░░░
    ░░░                            |   (Root Supervisor)  |                     ░░░
    ░░░                            +----------+-----------+                     ░░░
    ░░░                                       |                                 ░░░
    ░░░               +-----------------------+-----------------------+         ░░░
    ░░░               |                                               |         ░░░
    ░░░  +-----------------------+                   +-----------------------+  ░░░
    ·░░  |     BotManager        |                   |   CrawlerManager      |  ░░░
    ·░░  |-----------------------|                   |-----------------------|  ░░░
    ░░░  |  (Supervised Process) |                   |  (Supervised Process) |  ░░░
    ░░░  +----------+------------+                   +----------+------------+  ░░░
    ░░░             |                                           |               ░░░
    ░░░             v                                           v               ░░░
    ·░░  +-----------------------+                   +-----------------------+  ░░░
    ░░░  |   BotWorker 1         |                   |   CrawlerWorker 1     |  ░░░
    ░░░  |-----------------------|                   |-----------------------|  ░░░
    ░░░  |  (Supervised Process) |                   |  (Supervised Process) |  ░░░
    ░░░  +-----------------------+                   +-----------------------+  ░░░
    ░░░             |                                                           ░░░
    ░░░             v                                                           ░░░
    ░░░  +-----------------------+                                              ░░░
    ·░░  |   BotWorker 2         |                                              ░░░
    ░░░  |-----------------------|                                              ·░░
    ░░░  |  (Supervised Process) |                                              ░░░
    ░░░  +-----------------------+                                              ·░░
    ░░░                                                                         ░░░
    ░░░                                                                         ░░░
    ·░░  Basicamente processos que estão trabalhando em alguma tarefa podem     ·░░
    ░░░  ser monitorados, de forma que caso alguma falha aconteça, a            ░░░
    ░░░  aplicação conseguirá restaurar o trabalho de forma "automágica"        ░░░
    ·░░                                                                         ░░░
    ░░░  ### 3 - Implementações                                                 ░░░
    ░░░  Com esse modelo em mãos é possível planejar coisas como:               ░░░
    ░░░                                                                         ░░░
    ░░░  - Bots                                                                 ░░░
    ░░░      - De forma nativa é possível que várias instâncias de uma          ░░░
    ░░░      ferramenta se conecte a um cluster, executando trabalhando         ·░░
    ░░░      concorrente                                                        ░░░
    ░░░      - Por se tratar de aplicações erlang, dentro do elixir podemos     ·░░
    ░░░      criar árvores de supervisões, que ao detectar falhas se            ░░░
    ░░░      recuperam automaticamente                                          ░░░
    ░░░  - Coleta de informação                                                 ░░░
    ░░░      - Sem a necessidade de filas de mensagens como kafka ou            ░░░
    ░░░      similares é possível criar mecanismos para recebimento de          ░░░
    ░░░      mensagens async para execução de tarefas diversas                  ░░░
    ░░░      - Ótimo por ser "long running app" por natureza (telefonia/        ░░░
    ░░░      erlang...)                                                         ░░░
    ░░░  - Entre outros...                                                      ░░░
    ░░░                                                                         ░░░
    ░░░  Um exemplo que posso mencionar aqui que criei recente foi a            ·░░
    ░░░  ferramenta "binoculo", que é um simples banner grabber, que utiliza    ░░░
    ·░░  de concorrência:                                                       ·░░
    ░░░                                                                         ·░░
    ░░░                                                                         ░░░
    ·░░  Binoculo arch:                                                         ░░░
    ░░░                                                                         ░░░
    ░░░        +-------+                                                        ·░░
    ░░░        |  CLI  |                                                        ·░░
    ░░░        +-------+                                                        ░░░
    ░░░            |                                                            ░░░
    ░░░            v                   (Processo supervisionado).               ░░░
    ░░░  +------------------+     +------------------+                          ░░░
    ░░░  |    MAIN          |     |     Maestro      |                          ░░░
    ░░░  |  (Binoculo       |---->|  Spawning workers|                          ░░░
    ░░░  |   backend)       |     +------------------+                          ░░░
    ░░░  +------------------+                |                                  ░░░
    ░░░                                      |                                  ░░░
    ░░░                              +--------+---------+                       ░░░
    ░░░                              | Parallel workers |                       ░░░
    ░░░                              | +---+ +---+ +---+|                       ░░░
    ·░░                              | |W1 | |W2 | |W3 ||                       ░░░
    ░░░                              | +---+ +---+ +---+| (Cada worker executa  ░░░
    ░░░                              | +---+ +---+ +---+| trabalho de forma     ░░░
    ·░░                              | |W4 | |W5 | |W6 || concorrente)          ░░░
    ░░░                              | +---+ +---+ +---+|                       ░░░
    ░░░                              +------------------+                       ░░░
    ░░░                                      |                                  ░░░
    ·░░                                      v                                  ░░░
    ░░░                           +------------------+                          ·░░
    ░░░                           |  Save data to    |                          ░░░
    ░░░                           |  Meilisearch/DB  | (Outro processo          ░░░
    ░░░                           +------------------+ concorrente e            ░░░
    ░░░                           supervionado se comunica com N                ░░░
    ░░░                        fontes: banco de dados, motores de busca, etc)   ░░░
    ░░░                                                                         ·░░
    ·░░                                                                         ░░░
    ░░░  ref: https://github.com/girorme/binoculo                               ·░░
    ░░░                                                                         ░░░
    ·░░  A ferramenta é bem rápida (milhões de hosts em pouco tempo) e foi      ░░░
    ░░░  inspirada no pnscan (quem lembra em?) e poderia escalar utilizando as  ░░░
    ░░░  features de distribuição da linguagem, em breve prs sobre xD.          ░░░
    ░░░                                                                         ·░░
    ░░░  --=--=--=--=                                                           ·░░
    ░░░                                                                         ·░░
    ·░░  Uma aplicação concorrente e distribuída dentro do elixir pode rodar    ░░░
    ░░░  em máquinas ao redor do mundo, dentro um k8s ou simplesmente em        ░░░
    ·░░  algumas instâncias de docker na sua máquina local. A partir do         ░░░
    ░░░  momento que temos um cluster de aplicações, tudo pode se conectar e    ░░░
    ░░░  escalar (o whatsapp usufrui muito dessa arquitetura (eles amam         ░░░
    ░░░  erlang <3)).                                                           ░░░
    ░░░                                                                         ░░░
    ░░░  Para ilustrar as possibilidades uma simples aplicação se conectando    ░░░
    ░░░  entre si poderia ser obtida da seguinte forma:                         ░░░
    ░░░                                                                         ░░░
    ░░░  ~ init da aplicação                                                    ░░░
    ░░░                                                                         ░░░
    ░░░    $ mix new bot_manager --module BotManager                            ░░░
    ░░░                                                                         ·░░
    ░░░                                                                         ░░░
    ░░░  ~ criação de um genserver (processo com estado que pode ser            ░░░
    ░░░  supervisionado)                                                        ░░░
    ░░░                                                                         ░░░
    ░░░    defmodule BotManager do                                              ░░░
    ░░░      use GenServer                                                      ·░░
    ·░░                                                                         ░░░
    ░░░      def start_link(_) do                                               ░░░
    ░░░        GenServer.start_link(__MODULE__, :ok, name: __MODULE__)          ░░░
    ░░░      end                                                                ░░░
    ░░░                                                                         ·░░
    ·░░      def init(:ok) do                                                   ░░░
    ░░░        IO.puts("Botmanager from Node #{inspect(Node.self())} is         ·░░
    ░░░        starting...")                                                    ░░░
    ░░░        {:ok, []}                                                        ·░░
    ·░░      end                                                                ░░░
    ░░░                                                                         ░░░
    ░░░      def handle_cast({:send_message, message}, state) do                ░░░
    ░░░      # Essa função lida com as mensagens recebidas                      ░░░
    ░░░        IO.puts("Received message: #{message}")                          ░░░
    ░░░        {:noreply, state}                                                ░░░
    ░░░      end                                                                ░░░
    ░░░                                                                         ░░░
    ░░░      def send_message(node, message) do                                 ░░░
    ·░░        GenServer.cast({__MODULE__, node}, {:send_message, message})     ░░░
    ░░░   #a api que possibilita a chamada via qualquer entrada (cli, web,      ░░░
    ░░░   #etc)                                                                 ░░░
    ░░░      end                                                                ░░░
    ░░░    end                                                                  ░░░
    ·░░                                                                         ░░░
    ░░░                                                                         ░░░
    ░░░  ~ start da mesma aplicação duas vezes (poderia ser um k8s em pods      ·░░
    ░░░  diferentes, máquinas em regiões diferentes, etc)                       ░░░
    ░░░                                                                         ░░░
    ░░░    girorme@aristoteles [~/repositorios/research/tramoia/bot_manager]    ░░░
    ·░░    -> $ iex --sname node1 -S mix                                        ░░░
    ·░░    ... em outro terminal:                                               ░░░
    ░░░    iex --sname node2 -S mix                                             ░░░
    ░░░                                                                         ░░░
    ░░░                                                                         ·░░
    ░░░  Com os comandos acima, temos dois REPL's em tempo real. Dito isso:     ·░░
    ░░░                                                                         ░░░
    ░░░    iex(node1@aristoteles)2> Node.connect(:"node2@aristoteles")          ░░░
    ░░░    true                                                                 ·░░
    ░░░    ... --> outro terminal                                               ░░░
    ░░░    iex(node2@aristoteles)1> BotManager.start_link([])                   ░░░
    ░░░    Botmanager from Node :node2@aristoteles is starting...               ░░░
    ░░░                                                                         ░░░
    ░░░                                                                         ░░░
    ·░░  Com a conexão estabelecida é possível transitar mensagens entre os     ░░░
    ░░░  nós da aplicação:                                                      ░░░
    ░░░                                                                         ░░░
    ░░░    iex(node1@aristoteles)3>                                             ░░░
    ░░░    BotManager.send_message(:"node2@aristoteles", "Hi from node1")       ░░░
    ·░░    ...                                                                  ░░░
    ░░░                                                                         ░░░
    ·░░  No terminal 2:                                                         ·░░
    ░░░                                                                         ░░░
    ░░░    Received message: Hi from node1                                      ·░░
    ░░░    iex(node2@aristoteles)2>                                             ░░░
    ░░░                                                                         ░░░
    ░░░                                                                         ░░░
    ·░░  Aqui o simples texto poderia ser qualquer coisa que faça sentido no    ░░░
    ░░░  nosso contexto:                                                        ░░░
    ░░░                                                                         ░░░
    ░░░  - Uma máquina entrando para uma rede de bots                           ░░░
    ░░░  - Uma máquina se juntando ao cluster para executar trabalho de         ░░░
    ░░░  concorrente e distribuído (imagine um brute force ou crawler que roda  ·░░
    ·░░  infinitamente recebendo mais máquinas sobre demanda para compor um     ░░░
    ░░░  grande cluster)                                                        ░░░
    ░░░  - Sua criatividade que manda...                                        ░░░
    ░░░                                                                         ░░░
    ░░░                                                                         ·░░
    ░░░  ### 4 - Agradecimento                                                  ░░░
    ░░░                                                                         ·░░
    ░░░  Já dizia o mestre: De grão em grão a galinha enche o papo.             ·░░
    ░░░  E é isso amigo, uma gota do humilde conhecimento do que pode ser       ░░░
    ░░░  aplicado nas interwebs da vida.                                        ░░░
    ░░░  Meu agradecimento vai a quem mantém o hacking vivo e aos amigos que    ░░░
    ·░░  coletamos nessa longa jornada, um brinde aos true dos true!            ░░░
    ░░░                                                                         ░░░
    ·░░                                                                         ░░░
    ░░░   __i  Hey Nass, what're you doing here?                                ░░░
    ░░░  |---|   /                                                              ░░░
    ·░░  |[_]|  /                                                               ·░░
    ░░░  |:::|                                                                  ░░░
    ░░░  |:::|                                                                  ░░░
    ░░░  `\   \                                                                 ░░░
    ░░░    \_=_\ jsm                                                            ░░░
    ░░░                                                                         ░░░
    ·░░  I'm drinking beers and enjoying some bugs.                             ░░░
    ·░░                                                                         ·░░
    ░░░  No mais, n4s.                                                          ·░░
    ░░░                                                                         ░░░
    ·░░  []'s                                                                   ░░░
    ··░                                                                         ░··