defmodule ScenicFontAwesome.Solid do

  @moduledoc """
  Module which includes functions for rendering FontAwesome icons from the solid collection.
  """

  alias ScenicFontAwesome.Icon
  alias Scenic.Graph
  alias Scenic.Primitive

  defp spritesheet(:light), do: "icons/sprites_light_solid.png"
  defp spritesheet(_), do: "icons/sprites_dark_solid.png"

  @doc """
  Adds the 0 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/0

  ```
  graph
  |> fontawesome_0({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_0(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_0(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_0(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 200}, {50, 80}, opts)
  end
            
  @doc """
  Adds the 1 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/1

  ```
  graph
  |> fontawesome_1({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_1(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_1(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_1(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 0}, {50, 100}, opts)
  end
            
  @doc """
  Adds the 2 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/2

  ```
  graph
  |> fontawesome_2({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_2(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_2(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_2(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 200}, {50, 80}, opts)
  end
            
  @doc """
  Adds the 3 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/3

  ```
  graph
  |> fontawesome_3({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_3(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_3(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_3(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 200}, {50, 80}, opts)
  end
            
  @doc """
  Adds the 4 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/4

  ```
  graph
  |> fontawesome_4({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_4(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_4(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_4(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 133}, {50, 67}, opts)
  end
            
  @doc """
  Adds the 5 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/5

  ```
  graph
  |> fontawesome_5({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_5(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_5(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_5(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 0}, {50, 80}, opts)
  end
            
  @doc """
  Adds the 6 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/6

  ```
  graph
  |> fontawesome_6({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_6(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_6(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_6(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 80}, {50, 80}, opts)
  end
            
  @doc """
  Adds the 7 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/7

  ```
  graph
  |> fontawesome_7({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_7(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_7(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_7(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 160}, {50, 80}, opts)
  end
            
  @doc """
  Adds the 8 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/8

  ```
  graph
  |> fontawesome_8({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_8(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_8(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_8(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 0}, {50, 80}, opts)
  end
            
  @doc """
  Adds the 9 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/9

  ```
  graph
  |> fontawesome_9({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_9(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_9(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_9(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 80}, {50, 80}, opts)
  end
            
  @doc """
  Adds the a icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/a

  ```
  graph
  |> fontawesome_a({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_a(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_a(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_a(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 133}, {50, 67}, opts)
  end
            
  @doc """
  Adds the address-book icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/address-book

  ```
  graph
  |> fontawesome_address_book({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_address_book(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_address_book(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_address_book(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the address-card icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/address-card

  ```
  graph
  |> fontawesome_address_card({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_address_card(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_address_card(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_address_card(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 650}, {50, 44}, opts)
  end
            
  @doc """
  Adds the align-center icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/align-center

  ```
  graph
  |> fontawesome_align_center({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_align_center(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_align_center(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_align_center(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 335}, {50, 57}, opts)
  end
            
  @doc """
  Adds the align-justify icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/align-justify

  ```
  graph
  |> fontawesome_align_justify({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_align_justify(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_align_justify(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_align_justify(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 392}, {50, 57}, opts)
  end
            
  @doc """
  Adds the align-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/align-left

  ```
  graph
  |> fontawesome_align_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_align_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_align_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_align_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 449}, {50, 57}, opts)
  end
            
  @doc """
  Adds the align-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/align-right

  ```
  graph
  |> fontawesome_align_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_align_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_align_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_align_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 506}, {50, 57}, opts)
  end
            
  @doc """
  Adds the anchor-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/anchor-circle-check

  ```
  graph
  |> fontawesome_anchor_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_anchor_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_anchor_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_anchor_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 308}, {50, 40}, opts)
  end
            
  @doc """
  Adds the anchor-circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/anchor-circle-exclamation

  ```
  graph
  |> fontawesome_anchor_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_anchor_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_anchor_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_anchor_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 348}, {50, 40}, opts)
  end
            
  @doc """
  Adds the anchor-circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/anchor-circle-xmark

  ```
  graph
  |> fontawesome_anchor_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_anchor_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_anchor_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_anchor_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 388}, {50, 40}, opts)
  end
            
  @doc """
  Adds the anchor-lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/anchor-lock

  ```
  graph
  |> fontawesome_anchor_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_anchor_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_anchor_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_anchor_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 428}, {50, 40}, opts)
  end
            
  @doc """
  Adds the anchor icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/anchor

  ```
  graph
  |> fontawesome_anchor({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_anchor(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_anchor(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_anchor(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 694}, {50, 44}, opts)
  end
            
  @doc """
  Adds the angle-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/angle-down

  ```
  graph
  |> fontawesome_angle_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_angle_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_angle_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_angle_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 563}, {50, 57}, opts)
  end
            
  @doc """
  Adds the angle-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/angle-left

  ```
  graph
  |> fontawesome_angle_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_angle_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_angle_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_angle_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 160}, {50, 80}, opts)
  end
            
  @doc """
  Adds the angle-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/angle-right

  ```
  graph
  |> fontawesome_angle_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_angle_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_angle_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_angle_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 300}, {50, 80}, opts)
  end
            
  @doc """
  Adds the angle-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/angle-up

  ```
  graph
  |> fontawesome_angle_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_angle_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_angle_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_angle_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 620}, {50, 57}, opts)
  end
            
  @doc """
  Adds the angles-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/angles-down

  ```
  graph
  |> fontawesome_angles_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_angles_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_angles_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_angles_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 677}, {50, 57}, opts)
  end
            
  @doc """
  Adds the angles-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/angles-left

  ```
  graph
  |> fontawesome_angles_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_angles_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_angles_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_angles_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the angles-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/angles-right

  ```
  graph
  |> fontawesome_angles_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_angles_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_angles_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_angles_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the angles-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/angles-up

  ```
  graph
  |> fontawesome_angles_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_angles_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_angles_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_angles_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 734}, {50, 57}, opts)
  end
            
  @doc """
  Adds the ankh icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ankh

  ```
  graph
  |> fontawesome_ankh({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ankh(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ankh(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ankh(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 300}, {50, 80}, opts)
  end
            
  @doc """
  Adds the apple-whole icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/apple-whole

  ```
  graph
  |> fontawesome_apple_whole({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_apple_whole(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_apple_whole(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_apple_whole(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 791}, {50, 57}, opts)
  end
            
  @doc """
  Adds the archway icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/archway

  ```
  graph
  |> fontawesome_archway({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_archway(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_archway(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_archway(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrow-down-1-9 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-down-1-9

  ```
  graph
  |> fontawesome_arrow_down_1_9({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_down_1_9(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_down_1_9(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_down_1_9(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 738}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-down-9-1 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-down-9-1

  ```
  graph
  |> fontawesome_arrow_down_9_1({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_down_9_1(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_down_9_1(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_down_9_1(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 782}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-down-a-z icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-down-a-z

  ```
  graph
  |> fontawesome_arrow_down_a_z({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_down_a_z(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_down_a_z(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_down_a_z(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 826}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-down-long icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-down-long

  ```
  graph
  |> fontawesome_arrow_down_long({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_down_long(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_down_long(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_down_long(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 540}, {50, 67}, opts)
  end
            
  @doc """
  Adds the arrow-down-short-wide icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-down-short-wide

  ```
  graph
  |> fontawesome_arrow_down_short_wide({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_down_short_wide(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_down_short_wide(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_down_short_wide(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 870}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-down-up-across-line icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-down-up-across-line

  ```
  graph
  |> fontawesome_arrow_down_up_across_line({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_down_up_across_line(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_down_up_across_line(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_down_up_across_line(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 914}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-down-up-lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-down-up-lock

  ```
  graph
  |> fontawesome_arrow_down_up_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_down_up_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_down_up_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_down_up_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 468}, {50, 40}, opts)
  end
            
  @doc """
  Adds the arrow-down-wide-short icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-down-wide-short

  ```
  graph
  |> fontawesome_arrow_down_wide_short({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_down_wide_short(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_down_wide_short(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_down_wide_short(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 958}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-down-z-a icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-down-z-a

  ```
  graph
  |> fontawesome_arrow_down_z_a({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_down_z_a(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_down_z_a(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_down_z_a(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1002}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-down

  ```
  graph
  |> fontawesome_arrow_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 540}, {50, 67}, opts)
  end
            
  @doc """
  Adds the arrow-left-long icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-left-long

  ```
  graph
  |> fontawesome_arrow_left_long({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_left_long(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_left_long(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_left_long(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrow-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-left

  ```
  graph
  |> fontawesome_arrow_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 480}, {50, 57}, opts)
  end
            
  @doc """
  Adds the arrow-pointer icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-pointer

  ```
  graph
  |> fontawesome_arrow_pointer({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_pointer(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_pointer(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_pointer(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 300}, {50, 80}, opts)
  end
            
  @doc """
  Adds the arrow-right-arrow-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-right-arrow-left

  ```
  graph
  |> fontawesome_arrow_right_arrow_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_right_arrow_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_right_arrow_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_right_arrow_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 480}, {50, 57}, opts)
  end
            
  @doc """
  Adds the arrow-right-from-bracket icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-right-from-bracket

  ```
  graph
  |> fontawesome_arrow_right_from_bracket({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_right_from_bracket(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_right_from_bracket(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_right_from_bracket(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrow-right-long icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-right-long

  ```
  graph
  |> fontawesome_arrow_right_long({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_right_long(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_right_long(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_right_long(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrow-right-to-bracket icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-right-to-bracket

  ```
  graph
  |> fontawesome_arrow_right_to_bracket({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_right_to_bracket(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_right_to_bracket(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_right_to_bracket(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrow-right-to-city icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-right-to-city

  ```
  graph
  |> fontawesome_arrow_right_to_city({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_right_to_city(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_right_to_city(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_right_to_city(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 508}, {50, 40}, opts)
  end
            
  @doc """
  Adds the arrow-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-right

  ```
  graph
  |> fontawesome_arrow_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 400}, {50, 57}, opts)
  end
            
  @doc """
  Adds the arrow-rotate-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-rotate-left

  ```
  graph
  |> fontawesome_arrow_rotate_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_rotate_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_rotate_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_rotate_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrow-rotate-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-rotate-right

  ```
  graph
  |> fontawesome_arrow_rotate_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_rotate_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_rotate_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_rotate_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrow-trend-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-trend-down

  ```
  graph
  |> fontawesome_arrow_trend_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_trend_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_trend_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_trend_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1046}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-trend-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-trend-up

  ```
  graph
  |> fontawesome_arrow_trend_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_trend_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_trend_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_trend_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1090}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-turn-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-turn-down

  ```
  graph
  |> fontawesome_arrow_turn_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_turn_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_turn_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_turn_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 540}, {50, 67}, opts)
  end
            
  @doc """
  Adds the arrow-turn-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-turn-up

  ```
  graph
  |> fontawesome_arrow_turn_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_turn_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_turn_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_turn_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 540}, {50, 67}, opts)
  end
            
  @doc """
  Adds the arrow-up-1-9 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-up-1-9

  ```
  graph
  |> fontawesome_arrow_up_1_9({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_up_1_9(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_up_1_9(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_up_1_9(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1134}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-up-9-1 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-up-9-1

  ```
  graph
  |> fontawesome_arrow_up_9_1({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_up_9_1(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_up_9_1(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_up_9_1(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1178}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-up-a-z icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-up-a-z

  ```
  graph
  |> fontawesome_arrow_up_a_z({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_up_a_z(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_up_a_z(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_up_a_z(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1222}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-up-from-bracket icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-up-from-bracket

  ```
  graph
  |> fontawesome_arrow_up_from_bracket({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_up_from_bracket(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_up_from_bracket(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_up_from_bracket(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 320}, {50, 57}, opts)
  end
            
  @doc """
  Adds the arrow-up-from-ground-water icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-up-from-ground-water

  ```
  graph
  |> fontawesome_arrow_up_from_ground_water({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_up_from_ground_water(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_up_from_ground_water(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_up_from_ground_water(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1266}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-up-from-water-pump icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-up-from-water-pump

  ```
  graph
  |> fontawesome_arrow_up_from_water_pump({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_up_from_water_pump(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_up_from_water_pump(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_up_from_water_pump(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1310}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-up-long icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-up-long

  ```
  graph
  |> fontawesome_arrow_up_long({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_up_long(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_up_long(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_up_long(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 540}, {50, 67}, opts)
  end
            
  @doc """
  Adds the arrow-up-right-dots icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-up-right-dots

  ```
  graph
  |> fontawesome_arrow_up_right_dots({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_up_right_dots(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_up_right_dots(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_up_right_dots(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1354}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-up-right-from-square icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-up-right-from-square

  ```
  graph
  |> fontawesome_arrow_up_right_from_square({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_up_right_from_square(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_up_right_from_square(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_up_right_from_square(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrow-up-short-wide icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-up-short-wide

  ```
  graph
  |> fontawesome_arrow_up_short_wide({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_up_short_wide(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_up_short_wide(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_up_short_wide(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1398}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-up-wide-short icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-up-wide-short

  ```
  graph
  |> fontawesome_arrow_up_wide_short({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_up_wide_short(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_up_wide_short(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_up_wide_short(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1442}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-up-z-a icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-up-z-a

  ```
  graph
  |> fontawesome_arrow_up_z_a({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_up_z_a(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_up_z_a(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_up_z_a(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1486}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrow-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrow-up

  ```
  graph
  |> fontawesome_arrow_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrow_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrow_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrow_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 0}, {50, 67}, opts)
  end
            
  @doc """
  Adds the arrows-down-to-line icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-down-to-line

  ```
  graph
  |> fontawesome_arrows_down_to_line({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_down_to_line(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_down_to_line(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_down_to_line(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the arrows-down-to-people icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-down-to-people

  ```
  graph
  |> fontawesome_arrows_down_to_people({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_down_to_people(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_down_to_people(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_down_to_people(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 548}, {50, 40}, opts)
  end
            
  @doc """
  Adds the arrows-left-right-to-line icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-left-right-to-line

  ```
  graph
  |> fontawesome_arrows_left_right_to_line({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_left_right_to_line(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_left_right_to_line(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_left_right_to_line(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 588}, {50, 40}, opts)
  end
            
  @doc """
  Adds the arrows-left-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-left-right

  ```
  graph
  |> fontawesome_arrows_left_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_left_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_left_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_left_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrows-rotate icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-rotate

  ```
  graph
  |> fontawesome_arrows_rotate({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_rotate(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_rotate(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_rotate(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrows-spin icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-spin

  ```
  graph
  |> fontawesome_arrows_spin({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_spin(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_spin(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_spin(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrows-split-up-and-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-split-up-and-left

  ```
  graph
  |> fontawesome_arrows_split_up_and_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_split_up_and_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_split_up_and_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_split_up_and_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrows-to-circle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-to-circle

  ```
  graph
  |> fontawesome_arrows_to_circle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_to_circle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_to_circle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_to_circle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 628}, {50, 40}, opts)
  end
            
  @doc """
  Adds the arrows-to-dot icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-to-dot

  ```
  graph
  |> fontawesome_arrows_to_dot({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_to_dot(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_to_dot(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_to_dot(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1116}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrows-to-eye icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-to-eye

  ```
  graph
  |> fontawesome_arrows_to_eye({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_to_eye(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_to_eye(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_to_eye(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 668}, {50, 40}, opts)
  end
            
  @doc """
  Adds the arrows-turn-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-turn-right

  ```
  graph
  |> fontawesome_arrows_turn_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_turn_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_turn_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_turn_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 320}, {50, 57}, opts)
  end
            
  @doc """
  Adds the arrows-turn-to-dots icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-turn-to-dots

  ```
  graph
  |> fontawesome_arrows_turn_to_dots({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_turn_to_dots(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_turn_to_dots(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_turn_to_dots(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 0}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrows-up-down-left-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-up-down-left-right

  ```
  graph
  |> fontawesome_arrows_up_down_left_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_up_down_left_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_up_down_left_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_up_down_left_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 50}, {50, 50}, opts)
  end
            
  @doc """
  Adds the arrows-up-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-up-down

  ```
  graph
  |> fontawesome_arrows_up_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_up_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_up_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_up_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 300}, {50, 80}, opts)
  end
            
  @doc """
  Adds the arrows-up-to-line icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/arrows-up-to-line

  ```
  graph
  |> fontawesome_arrows_up_to_line({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_arrows_up_to_line(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_arrows_up_to_line(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_arrows_up_to_line(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the asterisk icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/asterisk

  ```
  graph
  |> fontawesome_asterisk({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_asterisk(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_asterisk(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_asterisk(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 67}, {50, 67}, opts)
  end
            
  @doc """
  Adds the at icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/at

  ```
  graph
  |> fontawesome_at({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_at(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_at(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_at(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the atom icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/atom

  ```
  graph
  |> fontawesome_atom({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_atom(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_atom(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_atom(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the audio-description icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/audio-description

  ```
  graph
  |> fontawesome_audio_description({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_audio_description(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_audio_description(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_audio_description(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the austral-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/austral-sign

  ```
  graph
  |> fontawesome_austral_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_austral_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_austral_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_austral_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 240}, {50, 57}, opts)
  end
            
  @doc """
  Adds the award icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/award

  ```
  graph
  |> fontawesome_award({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_award(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_award(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_award(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 134}, {50, 67}, opts)
  end
            
  @doc """
  Adds the b icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/b

  ```
  graph
  |> fontawesome_b({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_b(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_b(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_b(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 300}, {50, 80}, opts)
  end
            
  @doc """
  Adds the baby-carriage icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/baby-carriage

  ```
  graph
  |> fontawesome_baby_carriage({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_baby_carriage(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_baby_carriage(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_baby_carriage(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the baby icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/baby

  ```
  graph
  |> fontawesome_baby({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_baby(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_baby(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_baby(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 240}, {50, 57}, opts)
  end
            
  @doc """
  Adds the backward-fast icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/backward-fast

  ```
  graph
  |> fontawesome_backward_fast({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_backward_fast(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_backward_fast(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_backward_fast(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the backward-step icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/backward-step

  ```
  graph
  |> fontawesome_backward_step({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_backward_step(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_backward_step(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_backward_step(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 300}, {50, 80}, opts)
  end
            
  @doc """
  Adds the backward icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/backward

  ```
  graph
  |> fontawesome_backward({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_backward(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_backward(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_backward(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 300}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bacon icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bacon

  ```
  graph
  |> fontawesome_bacon({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bacon(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bacon(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bacon(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the bacteria icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bacteria

  ```
  graph
  |> fontawesome_bacteria({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bacteria(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bacteria(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bacteria(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 708}, {50, 40}, opts)
  end
            
  @doc """
  Adds the bacterium icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bacterium

  ```
  graph
  |> fontawesome_bacterium({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bacterium(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bacterium(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bacterium(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 350}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bag-shopping icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bag-shopping

  ```
  graph
  |> fontawesome_bag_shopping({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bag_shopping(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bag_shopping(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bag_shopping(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the bahai icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bahai

  ```
  graph
  |> fontawesome_bahai({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bahai(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bahai(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bahai(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the baht-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/baht-sign

  ```
  graph
  |> fontawesome_baht_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_baht_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_baht_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_baht_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 300}, {50, 80}, opts)
  end
            
  @doc """
  Adds the ban-smoking icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ban-smoking

  ```
  graph
  |> fontawesome_ban_smoking({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ban_smoking(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ban_smoking(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ban_smoking(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 400}, {50, 50}, opts)
  end
            
  @doc """
  Adds the ban icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ban

  ```
  graph
  |> fontawesome_ban({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ban(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ban(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ban(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 450}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bandage icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bandage

  ```
  graph
  |> fontawesome_bandage({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bandage(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bandage(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bandage(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 748}, {50, 40}, opts)
  end
            
  @doc """
  Adds the bangladeshi-taka-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bangladeshi-taka-sign

  ```
  graph
  |> fontawesome_bangladeshi_taka_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bangladeshi_taka_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bangladeshi_taka_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bangladeshi_taka_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 201}, {50, 67}, opts)
  end
            
  @doc """
  Adds the barcode icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/barcode

  ```
  graph
  |> fontawesome_barcode({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_barcode(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_barcode(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_barcode(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 500}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bars-progress icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bars-progress

  ```
  graph
  |> fontawesome_bars_progress({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bars_progress(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bars_progress(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bars_progress(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 550}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bars-staggered icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bars-staggered

  ```
  graph
  |> fontawesome_bars_staggered({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bars_staggered(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bars_staggered(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bars_staggered(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 600}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bars icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bars

  ```
  graph
  |> fontawesome_bars({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bars(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bars(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bars(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the baseball-bat-ball icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/baseball-bat-ball

  ```
  graph
  |> fontawesome_baseball_bat_ball({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_baseball_bat_ball(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_baseball_bat_ball(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_baseball_bat_ball(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 650}, {50, 50}, opts)
  end
            
  @doc """
  Adds the baseball icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/baseball

  ```
  graph
  |> fontawesome_baseball({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_baseball(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_baseball(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_baseball(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 700}, {50, 50}, opts)
  end
            
  @doc """
  Adds the basket-shopping icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/basket-shopping

  ```
  graph
  |> fontawesome_basket_shopping({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_basket_shopping(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_basket_shopping(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_basket_shopping(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the basketball icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/basketball

  ```
  graph
  |> fontawesome_basketball({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_basketball(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_basketball(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_basketball(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 750}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bath icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bath

  ```
  graph
  |> fontawesome_bath({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bath(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bath(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bath(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 800}, {50, 50}, opts)
  end
            
  @doc """
  Adds the battery-empty icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/battery-empty

  ```
  graph
  |> fontawesome_battery_empty({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_battery_empty(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_battery_empty(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_battery_empty(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the battery-full icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/battery-full

  ```
  graph
  |> fontawesome_battery_full({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_battery_full(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_battery_full(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_battery_full(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the battery-half icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/battery-half

  ```
  graph
  |> fontawesome_battery_half({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_battery_half(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_battery_half(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_battery_half(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the battery-quarter icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/battery-quarter

  ```
  graph
  |> fontawesome_battery_quarter({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_battery_quarter(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_battery_quarter(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_battery_quarter(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the battery-three-quarters icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/battery-three-quarters

  ```
  graph
  |> fontawesome_battery_three_quarters({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_battery_three_quarters(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_battery_three_quarters(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_battery_three_quarters(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the bed-pulse icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bed-pulse

  ```
  graph
  |> fontawesome_bed_pulse({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bed_pulse(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bed_pulse(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bed_pulse(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 788}, {50, 40}, opts)
  end
            
  @doc """
  Adds the bed icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bed

  ```
  graph
  |> fontawesome_bed({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bed(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bed(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bed(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 828}, {50, 40}, opts)
  end
            
  @doc """
  Adds the beer-mug-empty icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/beer-mug-empty

  ```
  graph
  |> fontawesome_beer_mug_empty({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_beer_mug_empty(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_beer_mug_empty(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_beer_mug_empty(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 850}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bell-concierge icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bell-concierge

  ```
  graph
  |> fontawesome_bell_concierge({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bell_concierge(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bell_concierge(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bell_concierge(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 900}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bell-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bell-slash

  ```
  graph
  |> fontawesome_bell_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bell_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bell_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bell_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 868}, {50, 40}, opts)
  end
            
  @doc """
  Adds the bell icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bell

  ```
  graph
  |> fontawesome_bell({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bell(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bell(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bell(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the bezier-curve icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bezier-curve

  ```
  graph
  |> fontawesome_bezier_curve({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bezier_curve(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bezier_curve(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bezier_curve(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 908}, {50, 40}, opts)
  end
            
  @doc """
  Adds the bicycle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bicycle

  ```
  graph
  |> fontawesome_bicycle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bicycle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bicycle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bicycle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 948}, {50, 40}, opts)
  end
            
  @doc """
  Adds the binoculars icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/binoculars

  ```
  graph
  |> fontawesome_binoculars({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_binoculars(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_binoculars(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_binoculars(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 950}, {50, 50}, opts)
  end
            
  @doc """
  Adds the biohazard icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/biohazard

  ```
  graph
  |> fontawesome_biohazard({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_biohazard(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_biohazard(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_biohazard(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the bitcoin-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bitcoin-sign

  ```
  graph
  |> fontawesome_bitcoin_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bitcoin_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bitcoin_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bitcoin_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 300}, {50, 80}, opts)
  end
            
  @doc """
  Adds the blender-phone icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/blender-phone

  ```
  graph
  |> fontawesome_blender_phone({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_blender_phone(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_blender_phone(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_blender_phone(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the blender icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/blender

  ```
  graph
  |> fontawesome_blender({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_blender(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_blender(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_blender(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1000}, {50, 50}, opts)
  end
            
  @doc """
  Adds the blog icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/blog

  ```
  graph
  |> fontawesome_blog({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_blog(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_blog(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_blog(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1050}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bold icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bold

  ```
  graph
  |> fontawesome_bold({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bold(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bold(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bold(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 268}, {50, 67}, opts)
  end
            
  @doc """
  Adds the bolt-lightning icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bolt-lightning

  ```
  graph
  |> fontawesome_bolt_lightning({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bolt_lightning(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bolt_lightning(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bolt_lightning(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 335}, {50, 67}, opts)
  end
            
  @doc """
  Adds the bolt icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bolt

  ```
  graph
  |> fontawesome_bolt({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bolt(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bolt(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bolt(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the bomb icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bomb

  ```
  graph
  |> fontawesome_bomb({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bomb(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bomb(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bomb(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bone icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bone

  ```
  graph
  |> fontawesome_bone({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bone(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bone(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bone(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the bong icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bong

  ```
  graph
  |> fontawesome_bong({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bong(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bong(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bong(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the book-atlas icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/book-atlas

  ```
  graph
  |> fontawesome_book_atlas({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_book_atlas(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_book_atlas(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_book_atlas(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the book-bible icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/book-bible

  ```
  graph
  |> fontawesome_book_bible({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_book_bible(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_book_bible(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_book_bible(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the book-bookmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/book-bookmark

  ```
  graph
  |> fontawesome_book_bookmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_book_bookmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_book_bookmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_book_bookmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the book-journal-whills icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/book-journal-whills

  ```
  graph
  |> fontawesome_book_journal_whills({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_book_journal_whills(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_book_journal_whills(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_book_journal_whills(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the book-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/book-medical

  ```
  graph
  |> fontawesome_book_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_book_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_book_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_book_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the book-open-reader icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/book-open-reader

  ```
  graph
  |> fontawesome_book_open_reader({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_book_open_reader(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_book_open_reader(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_book_open_reader(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the book-open icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/book-open

  ```
  graph
  |> fontawesome_book_open({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_book_open(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_book_open(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_book_open(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the book-quran icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/book-quran

  ```
  graph
  |> fontawesome_book_quran({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_book_quran(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_book_quran(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_book_quran(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the book-skull icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/book-skull

  ```
  graph
  |> fontawesome_book_skull({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_book_skull(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_book_skull(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_book_skull(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the book-tanakh icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/book-tanakh

  ```
  graph
  |> fontawesome_book_tanakh({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_book_tanakh(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_book_tanakh(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_book_tanakh(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the book icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/book

  ```
  graph
  |> fontawesome_book({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_book(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_book(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_book(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the bookmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bookmark

  ```
  graph
  |> fontawesome_bookmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bookmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bookmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bookmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 402}, {50, 67}, opts)
  end
            
  @doc """
  Adds the border-all icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/border-all

  ```
  graph
  |> fontawesome_border_all({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_border_all(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_border_all(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_border_all(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the border-none icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/border-none

  ```
  graph
  |> fontawesome_border_none({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_border_none(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_border_none(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_border_none(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the border-top-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/border-top-left

  ```
  graph
  |> fontawesome_border_top_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_border_top_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_border_top_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_border_top_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the bore-hole icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bore-hole

  ```
  graph
  |> fontawesome_bore_hole({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bore_hole(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bore_hole(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bore_hole(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bottle-droplet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bottle-droplet

  ```
  graph
  |> fontawesome_bottle_droplet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bottle_droplet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bottle_droplet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bottle_droplet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 0}, {50, 80}, opts)
  end
            
  @doc """
  Adds the bottle-water icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bottle-water

  ```
  graph
  |> fontawesome_bottle_water({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bottle_water(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bottle_water(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bottle_water(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 80}, {50, 80}, opts)
  end
            
  @doc """
  Adds the bowl-food icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bowl-food

  ```
  graph
  |> fontawesome_bowl_food({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bowl_food(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bowl_food(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bowl_food(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bowl-rice icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bowl-rice

  ```
  graph
  |> fontawesome_bowl_rice({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bowl_rice(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bowl_rice(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bowl_rice(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bowling-ball icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bowling-ball

  ```
  graph
  |> fontawesome_bowling_ball({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bowling_ball(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bowling_ball(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bowling_ball(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the box-archive icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/box-archive

  ```
  graph
  |> fontawesome_box_archive({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_box_archive(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_box_archive(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_box_archive(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the box-open icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/box-open

  ```
  graph
  |> fontawesome_box_open({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_box_open(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_box_open(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_box_open(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 988}, {50, 40}, opts)
  end
            
  @doc """
  Adds the box-tissue icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/box-tissue

  ```
  graph
  |> fontawesome_box_tissue({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_box_tissue(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_box_tissue(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_box_tissue(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the box icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/box

  ```
  graph
  |> fontawesome_box({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_box(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_box(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_box(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the boxes-packing icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/boxes-packing

  ```
  graph
  |> fontawesome_boxes_packing({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_boxes_packing(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_boxes_packing(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_boxes_packing(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1028}, {50, 40}, opts)
  end
            
  @doc """
  Adds the boxes-stacked icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/boxes-stacked

  ```
  graph
  |> fontawesome_boxes_stacked({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_boxes_stacked(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_boxes_stacked(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_boxes_stacked(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the braille icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/braille

  ```
  graph
  |> fontawesome_braille({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_braille(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_braille(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_braille(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1068}, {50, 40}, opts)
  end
            
  @doc """
  Adds the brain icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/brain

  ```
  graph
  |> fontawesome_brain({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_brain(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_brain(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_brain(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the brazilian-real-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/brazilian-real-sign

  ```
  graph
  |> fontawesome_brazilian_real_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_brazilian_real_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_brazilian_real_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_brazilian_real_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bread-slice icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bread-slice

  ```
  graph
  |> fontawesome_bread_slice({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bread_slice(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bread_slice(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bread_slice(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bridge-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bridge-circle-check

  ```
  graph
  |> fontawesome_bridge_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bridge_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bridge_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bridge_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1108}, {50, 40}, opts)
  end
            
  @doc """
  Adds the bridge-circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bridge-circle-exclamation

  ```
  graph
  |> fontawesome_bridge_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bridge_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bridge_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bridge_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1148}, {50, 40}, opts)
  end
            
  @doc """
  Adds the bridge-circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bridge-circle-xmark

  ```
  graph
  |> fontawesome_bridge_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bridge_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bridge_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bridge_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1188}, {50, 40}, opts)
  end
            
  @doc """
  Adds the bridge-lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bridge-lock

  ```
  graph
  |> fontawesome_bridge_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bridge_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bridge_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bridge_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1228}, {50, 40}, opts)
  end
            
  @doc """
  Adds the bridge-water icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bridge-water

  ```
  graph
  |> fontawesome_bridge_water({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bridge_water(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bridge_water(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bridge_water(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the bridge icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bridge

  ```
  graph
  |> fontawesome_bridge({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bridge(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bridge(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bridge(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the briefcase-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/briefcase-medical

  ```
  graph
  |> fontawesome_briefcase_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_briefcase_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_briefcase_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_briefcase_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the briefcase icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/briefcase

  ```
  graph
  |> fontawesome_briefcase({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_briefcase(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_briefcase(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_briefcase(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the broom-ball icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/broom-ball

  ```
  graph
  |> fontawesome_broom_ball({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_broom_ball(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_broom_ball(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_broom_ball(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the broom icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/broom

  ```
  graph
  |> fontawesome_broom({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_broom(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_broom(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_broom(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the brush icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/brush

  ```
  graph
  |> fontawesome_brush({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_brush(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_brush(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_brush(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 469}, {50, 67}, opts)
  end
            
  @doc """
  Adds the bucket icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bucket

  ```
  graph
  |> fontawesome_bucket({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bucket(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bucket(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bucket(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 888}, {50, 57}, opts)
  end
            
  @doc """
  Adds the bug-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bug-slash

  ```
  graph
  |> fontawesome_bug_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bug_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bug_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bug_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1268}, {50, 40}, opts)
  end
            
  @doc """
  Adds the bug icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bug

  ```
  graph
  |> fontawesome_bug({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bug(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bug(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bug(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bugs icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bugs

  ```
  graph
  |> fontawesome_bugs({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bugs(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bugs(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bugs(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the building-circle-arrow-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/building-circle-arrow-right

  ```
  graph
  |> fontawesome_building_circle_arrow_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_building_circle_arrow_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_building_circle_arrow_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_building_circle_arrow_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1308}, {50, 40}, opts)
  end
            
  @doc """
  Adds the building-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/building-circle-check

  ```
  graph
  |> fontawesome_building_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_building_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_building_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_building_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1348}, {50, 40}, opts)
  end
            
  @doc """
  Adds the building-circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/building-circle-exclamation

  ```
  graph
  |> fontawesome_building_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_building_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_building_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_building_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1388}, {50, 40}, opts)
  end
            
  @doc """
  Adds the building-circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/building-circle-xmark

  ```
  graph
  |> fontawesome_building_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_building_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_building_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_building_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1428}, {50, 40}, opts)
  end
            
  @doc """
  Adds the building-columns icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/building-columns

  ```
  graph
  |> fontawesome_building_columns({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_building_columns(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_building_columns(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_building_columns(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the building-flag icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/building-flag

  ```
  graph
  |> fontawesome_building_flag({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_building_flag(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_building_flag(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_building_flag(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1468}, {50, 40}, opts)
  end
            
  @doc """
  Adds the building-lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/building-lock

  ```
  graph
  |> fontawesome_building_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_building_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_building_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_building_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the building-ngo icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/building-ngo

  ```
  graph
  |> fontawesome_building_ngo({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_building_ngo(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_building_ngo(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_building_ngo(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 536}, {50, 67}, opts)
  end
            
  @doc """
  Adds the building-shield icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/building-shield

  ```
  graph
  |> fontawesome_building_shield({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_building_shield(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_building_shield(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_building_shield(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the building-un icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/building-un

  ```
  graph
  |> fontawesome_building_un({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_building_un(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_building_un(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_building_un(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the building-user icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/building-user

  ```
  graph
  |> fontawesome_building_user({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_building_user(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_building_user(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_building_user(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1508}, {50, 40}, opts)
  end
            
  @doc """
  Adds the building-wheat icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/building-wheat

  ```
  graph
  |> fontawesome_building_wheat({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_building_wheat(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_building_wheat(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_building_wheat(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1548}, {50, 40}, opts)
  end
            
  @doc """
  Adds the building icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/building

  ```
  graph
  |> fontawesome_building({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_building(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_building(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_building(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the bullhorn icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bullhorn

  ```
  graph
  |> fontawesome_bullhorn({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bullhorn(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bullhorn(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bullhorn(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bullseye icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bullseye

  ```
  graph
  |> fontawesome_bullseye({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bullseye(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bullseye(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bullseye(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the burger icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/burger

  ```
  graph
  |> fontawesome_burger({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_burger(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_burger(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_burger(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the burst icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/burst

  ```
  graph
  |> fontawesome_burst({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_burst(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_burst(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_burst(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the bus-simple icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bus-simple

  ```
  graph
  |> fontawesome_bus_simple({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bus_simple(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bus_simple(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bus_simple(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 0}, {50, 57}, opts)
  end
            
  @doc """
  Adds the bus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/bus

  ```
  graph
  |> fontawesome_bus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_bus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_bus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_bus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the business-time icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/business-time

  ```
  graph
  |> fontawesome_business_time({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_business_time(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_business_time(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_business_time(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1588}, {50, 40}, opts)
  end
            
  @doc """
  Adds the c icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/c

  ```
  graph
  |> fontawesome_c({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_c(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_c(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_c(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the cable-car icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cable-car

  ```
  graph
  |> fontawesome_cable_car({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cable_car(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cable_car(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cable_car(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the cake-candles icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cake-candles

  ```
  graph
  |> fontawesome_cake_candles({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cake_candles(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cake_candles(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cake_candles(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 57}, {50, 57}, opts)
  end
            
  @doc """
  Adds the calculator icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/calculator

  ```
  graph
  |> fontawesome_calculator({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_calculator(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_calculator(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_calculator(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the calendar-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/calendar-check

  ```
  graph
  |> fontawesome_calendar_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_calendar_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_calendar_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_calendar_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 114}, {50, 57}, opts)
  end
            
  @doc """
  Adds the calendar-day icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/calendar-day

  ```
  graph
  |> fontawesome_calendar_day({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_calendar_day(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_calendar_day(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_calendar_day(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 171}, {50, 57}, opts)
  end
            
  @doc """
  Adds the calendar-days icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/calendar-days

  ```
  graph
  |> fontawesome_calendar_days({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_calendar_days(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_calendar_days(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_calendar_days(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 228}, {50, 57}, opts)
  end
            
  @doc """
  Adds the calendar-minus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/calendar-minus

  ```
  graph
  |> fontawesome_calendar_minus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_calendar_minus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_calendar_minus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_calendar_minus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 285}, {50, 57}, opts)
  end
            
  @doc """
  Adds the calendar-plus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/calendar-plus

  ```
  graph
  |> fontawesome_calendar_plus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_calendar_plus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_calendar_plus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_calendar_plus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 342}, {50, 57}, opts)
  end
            
  @doc """
  Adds the calendar-week icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/calendar-week

  ```
  graph
  |> fontawesome_calendar_week({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_calendar_week(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_calendar_week(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_calendar_week(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 399}, {50, 57}, opts)
  end
            
  @doc """
  Adds the calendar-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/calendar-xmark

  ```
  graph
  |> fontawesome_calendar_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_calendar_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_calendar_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_calendar_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 456}, {50, 57}, opts)
  end
            
  @doc """
  Adds the calendar icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/calendar

  ```
  graph
  |> fontawesome_calendar({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_calendar(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_calendar(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_calendar(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 513}, {50, 57}, opts)
  end
            
  @doc """
  Adds the camera-retro icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/camera-retro

  ```
  graph
  |> fontawesome_camera_retro({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_camera_retro(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_camera_retro(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_camera_retro(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the camera-rotate icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/camera-rotate

  ```
  graph
  |> fontawesome_camera_rotate({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_camera_rotate(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_camera_rotate(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_camera_rotate(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1628}, {50, 40}, opts)
  end
            
  @doc """
  Adds the camera icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/camera

  ```
  graph
  |> fontawesome_camera({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_camera(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_camera(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_camera(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the campground icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/campground

  ```
  graph
  |> fontawesome_campground({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_campground(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_campground(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_campground(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the candy-cane icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/candy-cane

  ```
  graph
  |> fontawesome_candy_cane({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_candy_cane(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_candy_cane(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_candy_cane(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the cannabis icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cannabis

  ```
  graph
  |> fontawesome_cannabis({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cannabis(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cannabis(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cannabis(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the capsules icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/capsules

  ```
  graph
  |> fontawesome_capsules({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_capsules(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_capsules(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_capsules(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the car-battery icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/car-battery

  ```
  graph
  |> fontawesome_car_battery({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_car_battery(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_car_battery(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_car_battery(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the car-burst icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/car-burst

  ```
  graph
  |> fontawesome_car_burst({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_car_burst(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_car_burst(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_car_burst(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1668}, {50, 40}, opts)
  end
            
  @doc """
  Adds the car-on icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/car-on

  ```
  graph
  |> fontawesome_car_on({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_car_on(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_car_on(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_car_on(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1173}, {50, 50}, opts)
  end
            
  @doc """
  Adds the car-rear icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/car-rear

  ```
  graph
  |> fontawesome_car_rear({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_car_rear(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_car_rear(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_car_rear(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 0}, {50, 50}, opts)
  end
            
  @doc """
  Adds the car-side icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/car-side

  ```
  graph
  |> fontawesome_car_side({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_car_side(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_car_side(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_car_side(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1708}, {50, 40}, opts)
  end
            
  @doc """
  Adds the car-tunnel icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/car-tunnel

  ```
  graph
  |> fontawesome_car_tunnel({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_car_tunnel(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_car_tunnel(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_car_tunnel(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 50}, {50, 50}, opts)
  end
            
  @doc """
  Adds the car icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/car

  ```
  graph
  |> fontawesome_car({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_car(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_car(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_car(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the caravan icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/caravan

  ```
  graph
  |> fontawesome_caravan({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_caravan(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_caravan(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_caravan(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1530}, {50, 40}, opts)
  end
            
  @doc """
  Adds the caret-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/caret-down

  ```
  graph
  |> fontawesome_caret_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_caret_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_caret_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_caret_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 160}, {50, 80}, opts)
  end
            
  @doc """
  Adds the caret-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/caret-left

  ```
  graph
  |> fontawesome_caret_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_caret_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_caret_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_caret_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 100}, {50, 100}, opts)
  end
            
  @doc """
  Adds the caret-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/caret-right

  ```
  graph
  |> fontawesome_caret_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_caret_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_caret_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_caret_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 0}, {50, 100}, opts)
  end
            
  @doc """
  Adds the caret-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/caret-up

  ```
  graph
  |> fontawesome_caret_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_caret_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_caret_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_caret_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 240}, {50, 80}, opts)
  end
            
  @doc """
  Adds the carrot icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/carrot

  ```
  graph
  |> fontawesome_carrot({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_carrot(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_carrot(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_carrot(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the cart-arrow-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cart-arrow-down

  ```
  graph
  |> fontawesome_cart_arrow_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cart_arrow_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cart_arrow_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cart_arrow_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the cart-flatbed-suitcase icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cart-flatbed-suitcase

  ```
  graph
  |> fontawesome_cart_flatbed_suitcase({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cart_flatbed_suitcase(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cart_flatbed_suitcase(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cart_flatbed_suitcase(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 848}, {50, 40}, opts)
  end
            
  @doc """
  Adds the cart-flatbed icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cart-flatbed

  ```
  graph
  |> fontawesome_cart_flatbed({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cart_flatbed(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cart_flatbed(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cart_flatbed(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the cart-plus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cart-plus

  ```
  graph
  |> fontawesome_cart_plus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cart_plus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cart_plus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cart_plus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the cart-shopping icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cart-shopping

  ```
  graph
  |> fontawesome_cart_shopping({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cart_shopping(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cart_shopping(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cart_shopping(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the cash-register icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cash-register

  ```
  graph
  |> fontawesome_cash_register({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cash_register(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cash_register(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cash_register(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the cat icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cat

  ```
  graph
  |> fontawesome_cat({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cat(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cat(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cat(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the cedi-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cedi-sign

  ```
  graph
  |> fontawesome_cedi_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cedi_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cedi_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cedi_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the cent-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cent-sign

  ```
  graph
  |> fontawesome_cent_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cent_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cent_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cent_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the certificate icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/certificate

  ```
  graph
  |> fontawesome_certificate({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_certificate(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_certificate(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_certificate(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the chair icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chair

  ```
  graph
  |> fontawesome_chair({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chair(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chair(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chair(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 570}, {50, 57}, opts)
  end
            
  @doc """
  Adds the chalkboard-user icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chalkboard-user

  ```
  graph
  |> fontawesome_chalkboard_user({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chalkboard_user(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chalkboard_user(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chalkboard_user(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the chalkboard icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chalkboard

  ```
  graph
  |> fontawesome_chalkboard({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chalkboard(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chalkboard(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chalkboard(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the champagne-glasses icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/champagne-glasses

  ```
  graph
  |> fontawesome_champagne_glasses({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_champagne_glasses(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_champagne_glasses(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_champagne_glasses(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the charging-station icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/charging-station

  ```
  graph
  |> fontawesome_charging_station({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_charging_station(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_charging_station(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_charging_station(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the chart-area icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chart-area

  ```
  graph
  |> fontawesome_chart_area({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chart_area(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chart_area(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chart_area(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 300}, {50, 50}, opts)
  end
            
  @doc """
  Adds the chart-bar icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chart-bar

  ```
  graph
  |> fontawesome_chart_bar({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chart_bar(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chart_bar(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chart_bar(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 350}, {50, 50}, opts)
  end
            
  @doc """
  Adds the chart-column icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chart-column

  ```
  graph
  |> fontawesome_chart_column({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chart_column(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chart_column(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chart_column(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 400}, {50, 50}, opts)
  end
            
  @doc """
  Adds the chart-gantt icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chart-gantt

  ```
  graph
  |> fontawesome_chart_gantt({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chart_gantt(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chart_gantt(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chart_gantt(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 450}, {50, 50}, opts)
  end
            
  @doc """
  Adds the chart-line icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chart-line

  ```
  graph
  |> fontawesome_chart_line({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chart_line(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chart_line(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chart_line(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 500}, {50, 50}, opts)
  end
            
  @doc """
  Adds the chart-pie icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chart-pie

  ```
  graph
  |> fontawesome_chart_pie({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chart_pie(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chart_pie(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chart_pie(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1573}, {50, 44}, opts)
  end
            
  @doc """
  Adds the chart-simple icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chart-simple

  ```
  graph
  |> fontawesome_chart_simple({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chart_simple(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chart_simple(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chart_simple(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 627}, {50, 57}, opts)
  end
            
  @doc """
  Adds the check-double icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/check-double

  ```
  graph
  |> fontawesome_check_double({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_check_double(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_check_double(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_check_double(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 684}, {50, 57}, opts)
  end
            
  @doc """
  Adds the check-to-slot icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/check-to-slot

  ```
  graph
  |> fontawesome_check_to_slot({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_check_to_slot(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_check_to_slot(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_check_to_slot(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 0}, {50, 44}, opts)
  end
            
  @doc """
  Adds the check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/check

  ```
  graph
  |> fontawesome_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 741}, {50, 57}, opts)
  end
            
  @doc """
  Adds the cheese icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cheese

  ```
  graph
  |> fontawesome_cheese({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cheese(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cheese(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cheese(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 550}, {50, 50}, opts)
  end
            
  @doc """
  Adds the chess-bishop icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chess-bishop

  ```
  graph
  |> fontawesome_chess_bishop({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chess_bishop(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chess_bishop(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chess_bishop(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 0}, {50, 80}, opts)
  end
            
  @doc """
  Adds the chess-board icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chess-board

  ```
  graph
  |> fontawesome_chess_board({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chess_board(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chess_board(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chess_board(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 798}, {50, 57}, opts)
  end
            
  @doc """
  Adds the chess-king icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chess-king

  ```
  graph
  |> fontawesome_chess_king({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chess_king(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chess_king(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chess_king(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 855}, {50, 57}, opts)
  end
            
  @doc """
  Adds the chess-knight icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chess-knight

  ```
  graph
  |> fontawesome_chess_knight({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chess_knight(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chess_knight(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chess_knight(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 0}, {50, 57}, opts)
  end
            
  @doc """
  Adds the chess-pawn icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chess-pawn

  ```
  graph
  |> fontawesome_chess_pawn({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chess_pawn(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chess_pawn(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chess_pawn(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 80}, {50, 80}, opts)
  end
            
  @doc """
  Adds the chess-queen icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chess-queen

  ```
  graph
  |> fontawesome_chess_queen({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chess_queen(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chess_queen(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chess_queen(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 600}, {50, 50}, opts)
  end
            
  @doc """
  Adds the chess-rook icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chess-rook

  ```
  graph
  |> fontawesome_chess_rook({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chess_rook(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chess_rook(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chess_rook(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 57}, {50, 57}, opts)
  end
            
  @doc """
  Adds the chess icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chess

  ```
  graph
  |> fontawesome_chess({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chess(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chess(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chess(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 650}, {50, 50}, opts)
  end
            
  @doc """
  Adds the chevron-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chevron-down

  ```
  graph
  |> fontawesome_chevron_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chevron_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chevron_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chevron_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 700}, {50, 50}, opts)
  end
            
  @doc """
  Adds the chevron-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chevron-left

  ```
  graph
  |> fontawesome_chevron_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chevron_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chevron_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chevron_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 160}, {50, 80}, opts)
  end
            
  @doc """
  Adds the chevron-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chevron-right

  ```
  graph
  |> fontawesome_chevron_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chevron_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chevron_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chevron_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 240}, {50, 80}, opts)
  end
            
  @doc """
  Adds the chevron-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/chevron-up

  ```
  graph
  |> fontawesome_chevron_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_chevron_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_chevron_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_chevron_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 750}, {50, 50}, opts)
  end
            
  @doc """
  Adds the child-combatant icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/child-combatant

  ```
  graph
  |> fontawesome_child_combatant({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_child_combatant(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_child_combatant(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_child_combatant(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 44}, {50, 44}, opts)
  end
            
  @doc """
  Adds the child-dress icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/child-dress

  ```
  graph
  |> fontawesome_child_dress({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_child_dress(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_child_dress(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_child_dress(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 380}, {50, 80}, opts)
  end
            
  @doc """
  Adds the child-reaching icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/child-reaching

  ```
  graph
  |> fontawesome_child_reaching({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_child_reaching(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_child_reaching(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_child_reaching(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the child icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/child

  ```
  graph
  |> fontawesome_child({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_child(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_child(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_child(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 380}, {50, 80}, opts)
  end
            
  @doc """
  Adds the children icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/children

  ```
  graph
  |> fontawesome_children({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_children(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_children(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_children(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the church icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/church

  ```
  graph
  |> fontawesome_church({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_church(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_church(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_church(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the circle-arrow-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-arrow-down

  ```
  graph
  |> fontawesome_circle_arrow_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_arrow_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_arrow_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_arrow_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 800}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-arrow-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-arrow-left

  ```
  graph
  |> fontawesome_circle_arrow_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_arrow_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_arrow_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_arrow_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 850}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-arrow-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-arrow-right

  ```
  graph
  |> fontawesome_circle_arrow_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_arrow_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_arrow_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_arrow_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 900}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-arrow-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-arrow-up

  ```
  graph
  |> fontawesome_circle_arrow_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_arrow_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_arrow_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_arrow_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 950}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-check

  ```
  graph
  |> fontawesome_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1000}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-chevron-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-chevron-down

  ```
  graph
  |> fontawesome_circle_chevron_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_chevron_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_chevron_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_chevron_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1050}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-chevron-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-chevron-left

  ```
  graph
  |> fontawesome_circle_chevron_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_chevron_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_chevron_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_chevron_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-chevron-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-chevron-right

  ```
  graph
  |> fontawesome_circle_chevron_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_chevron_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_chevron_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_chevron_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-chevron-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-chevron-up

  ```
  graph
  |> fontawesome_circle_chevron_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_chevron_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_chevron_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_chevron_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-dollar-to-slot icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-dollar-to-slot

  ```
  graph
  |> fontawesome_circle_dollar_to_slot({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_dollar_to_slot(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_dollar_to_slot(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_dollar_to_slot(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-dot icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-dot

  ```
  graph
  |> fontawesome_circle_dot({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_dot(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_dot(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_dot(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-down

  ```
  graph
  |> fontawesome_circle_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-exclamation

  ```
  graph
  |> fontawesome_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-h icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-h

  ```
  graph
  |> fontawesome_circle_h({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_h(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_h(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_h(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-half-stroke icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-half-stroke

  ```
  graph
  |> fontawesome_circle_half_stroke({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_half_stroke(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_half_stroke(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_half_stroke(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-info icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-info

  ```
  graph
  |> fontawesome_circle_info({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_info(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_info(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_info(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-left

  ```
  graph
  |> fontawesome_circle_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-minus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-minus

  ```
  graph
  |> fontawesome_circle_minus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_minus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_minus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_minus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-nodes icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-nodes

  ```
  graph
  |> fontawesome_circle_nodes({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_nodes(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_nodes(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_nodes(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-notch icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-notch

  ```
  graph
  |> fontawesome_circle_notch({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_notch(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_notch(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_notch(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-pause icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-pause

  ```
  graph
  |> fontawesome_circle_pause({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_pause(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_pause(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_pause(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-play icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-play

  ```
  graph
  |> fontawesome_circle_play({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_play(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_play(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_play(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-plus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-plus

  ```
  graph
  |> fontawesome_circle_plus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_plus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_plus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_plus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-question icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-question

  ```
  graph
  |> fontawesome_circle_question({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_question(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_question(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_question(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-radiation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-radiation

  ```
  graph
  |> fontawesome_circle_radiation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_radiation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_radiation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_radiation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-right

  ```
  graph
  |> fontawesome_circle_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-stop icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-stop

  ```
  graph
  |> fontawesome_circle_stop({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_stop(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_stop(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_stop(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-up

  ```
  graph
  |> fontawesome_circle_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-user icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-user

  ```
  graph
  |> fontawesome_circle_user({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_user(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_user(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_user(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle-xmark

  ```
  graph
  |> fontawesome_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the circle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/circle

  ```
  graph
  |> fontawesome_circle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_circle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_circle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_circle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the city icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/city

  ```
  graph
  |> fontawesome_city({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_city(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_city(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_city(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the clapperboard icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/clapperboard

  ```
  graph
  |> fontawesome_clapperboard({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_clapperboard(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_clapperboard(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_clapperboard(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the clipboard-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/clipboard-check

  ```
  graph
  |> fontawesome_clipboard_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_clipboard_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_clipboard_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_clipboard_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the clipboard-list icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/clipboard-list

  ```
  graph
  |> fontawesome_clipboard_list({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_clipboard_list(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_clipboard_list(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_clipboard_list(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the clipboard-question icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/clipboard-question

  ```
  graph
  |> fontawesome_clipboard_question({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_clipboard_question(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_clipboard_question(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_clipboard_question(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the clipboard-user icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/clipboard-user

  ```
  graph
  |> fontawesome_clipboard_user({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_clipboard_user(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_clipboard_user(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_clipboard_user(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the clipboard icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/clipboard

  ```
  graph
  |> fontawesome_clipboard({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_clipboard(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_clipboard(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_clipboard(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the clock-rotate-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/clock-rotate-left

  ```
  graph
  |> fontawesome_clock_rotate_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_clock_rotate_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_clock_rotate_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_clock_rotate_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the clock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/clock

  ```
  graph
  |> fontawesome_clock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_clock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_clock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_clock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1223}, {50, 50}, opts)
  end
            
  @doc """
  Adds the clone icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/clone

  ```
  graph
  |> fontawesome_clone({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_clone(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_clone(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_clone(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 0}, {50, 50}, opts)
  end
            
  @doc """
  Adds the closed-captioning icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/closed-captioning

  ```
  graph
  |> fontawesome_closed_captioning({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_closed_captioning(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_closed_captioning(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_closed_captioning(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 88}, {50, 44}, opts)
  end
            
  @doc """
  Adds the cloud-arrow-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cloud-arrow-down

  ```
  graph
  |> fontawesome_cloud_arrow_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cloud_arrow_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cloud_arrow_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cloud_arrow_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the cloud-arrow-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cloud-arrow-up

  ```
  graph
  |> fontawesome_cloud_arrow_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cloud_arrow_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cloud_arrow_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cloud_arrow_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the cloud-bolt icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cloud-bolt

  ```
  graph
  |> fontawesome_cloud_bolt({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cloud_bolt(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cloud_bolt(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cloud_bolt(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 50}, {50, 50}, opts)
  end
            
  @doc """
  Adds the cloud-meatball icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cloud-meatball

  ```
  graph
  |> fontawesome_cloud_meatball({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cloud_meatball(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cloud_meatball(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cloud_meatball(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the cloud-moon-rain icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cloud-moon-rain

  ```
  graph
  |> fontawesome_cloud_moon_rain({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cloud_moon_rain(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cloud_moon_rain(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cloud_moon_rain(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 132}, {50, 44}, opts)
  end
            
  @doc """
  Adds the cloud-moon icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cloud-moon

  ```
  graph
  |> fontawesome_cloud_moon({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cloud_moon(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cloud_moon(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cloud_moon(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the cloud-rain icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cloud-rain

  ```
  graph
  |> fontawesome_cloud_rain({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cloud_rain(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cloud_rain(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cloud_rain(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the cloud-showers-heavy icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cloud-showers-heavy

  ```
  graph
  |> fontawesome_cloud_showers_heavy({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cloud_showers_heavy(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cloud_showers_heavy(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cloud_showers_heavy(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the cloud-showers-water icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cloud-showers-water

  ```
  graph
  |> fontawesome_cloud_showers_water({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cloud_showers_water(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cloud_showers_water(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cloud_showers_water(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 176}, {50, 44}, opts)
  end
            
  @doc """
  Adds the cloud-sun-rain icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cloud-sun-rain

  ```
  graph
  |> fontawesome_cloud_sun_rain({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cloud_sun_rain(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cloud_sun_rain(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cloud_sun_rain(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the cloud-sun icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cloud-sun

  ```
  graph
  |> fontawesome_cloud_sun({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cloud_sun(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cloud_sun(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cloud_sun(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the cloud icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cloud

  ```
  graph
  |> fontawesome_cloud({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cloud(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cloud(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cloud(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the clover icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/clover

  ```
  graph
  |> fontawesome_clover({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_clover(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_clover(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_clover(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 114}, {50, 57}, opts)
  end
            
  @doc """
  Adds the code-branch icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/code-branch

  ```
  graph
  |> fontawesome_code_branch({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_code_branch(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_code_branch(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_code_branch(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 171}, {50, 57}, opts)
  end
            
  @doc """
  Adds the code-commit icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/code-commit

  ```
  graph
  |> fontawesome_code_commit({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_code_commit(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_code_commit(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_code_commit(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the code-compare icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/code-compare

  ```
  graph
  |> fontawesome_code_compare({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_code_compare(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_code_compare(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_code_compare(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the code-fork icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/code-fork

  ```
  graph
  |> fontawesome_code_fork({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_code_fork(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_code_fork(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_code_fork(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 228}, {50, 57}, opts)
  end
            
  @doc """
  Adds the code-merge icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/code-merge

  ```
  graph
  |> fontawesome_code_merge({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_code_merge(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_code_merge(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_code_merge(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 285}, {50, 57}, opts)
  end
            
  @doc """
  Adds the code-pull-request icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/code-pull-request

  ```
  graph
  |> fontawesome_code_pull_request({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_code_pull_request(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_code_pull_request(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_code_pull_request(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 300}, {50, 50}, opts)
  end
            
  @doc """
  Adds the code icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/code

  ```
  graph
  |> fontawesome_code({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_code(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_code(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_code(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the coins icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/coins

  ```
  graph
  |> fontawesome_coins({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_coins(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_coins(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_coins(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 350}, {50, 50}, opts)
  end
            
  @doc """
  Adds the colon-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/colon-sign

  ```
  graph
  |> fontawesome_colon_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_colon_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_colon_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_colon_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the comment-dollar icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/comment-dollar

  ```
  graph
  |> fontawesome_comment_dollar({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_comment_dollar(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_comment_dollar(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_comment_dollar(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 400}, {50, 50}, opts)
  end
            
  @doc """
  Adds the comment-dots icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/comment-dots

  ```
  graph
  |> fontawesome_comment_dots({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_comment_dots(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_comment_dots(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_comment_dots(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 450}, {50, 50}, opts)
  end
            
  @doc """
  Adds the comment-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/comment-medical

  ```
  graph
  |> fontawesome_comment_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_comment_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_comment_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_comment_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 500}, {50, 50}, opts)
  end
            
  @doc """
  Adds the comment-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/comment-slash

  ```
  graph
  |> fontawesome_comment_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_comment_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_comment_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_comment_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the comment-sms icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/comment-sms

  ```
  graph
  |> fontawesome_comment_sms({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_comment_sms(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_comment_sms(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_comment_sms(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 550}, {50, 50}, opts)
  end
            
  @doc """
  Adds the comment icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/comment

  ```
  graph
  |> fontawesome_comment({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_comment(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_comment(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_comment(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 600}, {50, 50}, opts)
  end
            
  @doc """
  Adds the comments-dollar icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/comments-dollar

  ```
  graph
  |> fontawesome_comments_dollar({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_comments_dollar(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_comments_dollar(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_comments_dollar(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the comments icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/comments

  ```
  graph
  |> fontawesome_comments({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_comments(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_comments(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_comments(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the compact-disc icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/compact-disc

  ```
  graph
  |> fontawesome_compact_disc({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_compact_disc(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_compact_disc(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_compact_disc(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 650}, {50, 50}, opts)
  end
            
  @doc """
  Adds the compass-drafting icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/compass-drafting

  ```
  graph
  |> fontawesome_compass_drafting({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_compass_drafting(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_compass_drafting(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_compass_drafting(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 700}, {50, 50}, opts)
  end
            
  @doc """
  Adds the compass icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/compass

  ```
  graph
  |> fontawesome_compass({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_compass(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_compass(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_compass(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 750}, {50, 50}, opts)
  end
            
  @doc """
  Adds the compress icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/compress

  ```
  graph
  |> fontawesome_compress({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_compress(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_compress(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_compress(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 342}, {50, 57}, opts)
  end
            
  @doc """
  Adds the computer-mouse icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/computer-mouse

  ```
  graph
  |> fontawesome_computer_mouse({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_computer_mouse(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_computer_mouse(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_computer_mouse(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 620}, {50, 67}, opts)
  end
            
  @doc """
  Adds the computer icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/computer

  ```
  graph
  |> fontawesome_computer({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_computer(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_computer(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_computer(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the cookie-bite icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cookie-bite

  ```
  graph
  |> fontawesome_cookie_bite({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cookie_bite(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cookie_bite(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cookie_bite(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 800}, {50, 50}, opts)
  end
            
  @doc """
  Adds the cookie icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cookie

  ```
  graph
  |> fontawesome_cookie({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cookie(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cookie(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cookie(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 850}, {50, 50}, opts)
  end
            
  @doc """
  Adds the copy icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/copy

  ```
  graph
  |> fontawesome_copy({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_copy(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_copy(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_copy(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 399}, {50, 57}, opts)
  end
            
  @doc """
  Adds the copyright icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/copyright

  ```
  graph
  |> fontawesome_copyright({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_copyright(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_copyright(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_copyright(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 900}, {50, 50}, opts)
  end
            
  @doc """
  Adds the couch icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/couch

  ```
  graph
  |> fontawesome_couch({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_couch(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_couch(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_couch(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the cow icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cow

  ```
  graph
  |> fontawesome_cow({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cow(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cow(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cow(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the credit-card icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/credit-card

  ```
  graph
  |> fontawesome_credit_card({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_credit_card(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_credit_card(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_credit_card(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 220}, {50, 44}, opts)
  end
            
  @doc """
  Adds the crop-simple icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/crop-simple

  ```
  graph
  |> fontawesome_crop_simple({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_crop_simple(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_crop_simple(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_crop_simple(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 950}, {50, 50}, opts)
  end
            
  @doc """
  Adds the crop icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/crop

  ```
  graph
  |> fontawesome_crop({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_crop(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_crop(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_crop(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1000}, {50, 50}, opts)
  end
            
  @doc """
  Adds the cross icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cross

  ```
  graph
  |> fontawesome_cross({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cross(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cross(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cross(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 0}, {50, 67}, opts)
  end
            
  @doc """
  Adds the crosshairs icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/crosshairs

  ```
  graph
  |> fontawesome_crosshairs({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_crosshairs(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_crosshairs(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_crosshairs(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1050}, {50, 50}, opts)
  end
            
  @doc """
  Adds the crow icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/crow

  ```
  graph
  |> fontawesome_crow({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_crow(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_crow(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_crow(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the crown icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/crown

  ```
  graph
  |> fontawesome_crown({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_crown(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_crown(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_crown(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 264}, {50, 44}, opts)
  end
            
  @doc """
  Adds the crutch icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/crutch

  ```
  graph
  |> fontawesome_crutch({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_crutch(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_crutch(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_crutch(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the cruzeiro-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cruzeiro-sign

  ```
  graph
  |> fontawesome_cruzeiro_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cruzeiro_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cruzeiro_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cruzeiro_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 456}, {50, 57}, opts)
  end
            
  @doc """
  Adds the cube icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cube

  ```
  graph
  |> fontawesome_cube({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cube(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cube(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cube(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the cubes-stacked icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cubes-stacked

  ```
  graph
  |> fontawesome_cubes_stacked({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cubes_stacked(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cubes_stacked(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cubes_stacked(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 513}, {50, 57}, opts)
  end
            
  @doc """
  Adds the cubes icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/cubes

  ```
  graph
  |> fontawesome_cubes({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_cubes(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_cubes(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_cubes(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 308}, {50, 44}, opts)
  end
            
  @doc """
  Adds the d icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/d

  ```
  graph
  |> fontawesome_d({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_d(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_d(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_d(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 67}, {50, 67}, opts)
  end
            
  @doc """
  Adds the database icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/database

  ```
  graph
  |> fontawesome_database({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_database(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_database(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_database(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 570}, {50, 57}, opts)
  end
            
  @doc """
  Adds the delete-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/delete-left

  ```
  graph
  |> fontawesome_delete_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_delete_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_delete_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_delete_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 352}, {50, 44}, opts)
  end
            
  @doc """
  Adds the democrat icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/democrat

  ```
  graph
  |> fontawesome_democrat({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_democrat(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_democrat(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_democrat(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the desktop icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/desktop

  ```
  graph
  |> fontawesome_desktop({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_desktop(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_desktop(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_desktop(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 396}, {50, 44}, opts)
  end
            
  @doc """
  Adds the dharmachakra icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dharmachakra

  ```
  graph
  |> fontawesome_dharmachakra({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dharmachakra(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dharmachakra(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dharmachakra(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the diagram-next icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/diagram-next

  ```
  graph
  |> fontawesome_diagram_next({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_diagram_next(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_diagram_next(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_diagram_next(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the diagram-predecessor icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/diagram-predecessor

  ```
  graph
  |> fontawesome_diagram_predecessor({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_diagram_predecessor(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_diagram_predecessor(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_diagram_predecessor(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the diagram-project icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/diagram-project

  ```
  graph
  |> fontawesome_diagram_project({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_diagram_project(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_diagram_project(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_diagram_project(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 440}, {50, 44}, opts)
  end
            
  @doc """
  Adds the diagram-successor icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/diagram-successor

  ```
  graph
  |> fontawesome_diagram_successor({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_diagram_successor(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_diagram_successor(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_diagram_successor(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the diamond-turn-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/diamond-turn-right

  ```
  graph
  |> fontawesome_diamond_turn_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_diamond_turn_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_diamond_turn_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_diamond_turn_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the diamond icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/diamond

  ```
  graph
  |> fontawesome_diamond({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_diamond(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_diamond(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_diamond(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the dice-d20 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dice-d20

  ```
  graph
  |> fontawesome_dice_d20({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dice_d20(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dice_d20(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dice_d20(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the dice-d6 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dice-d6

  ```
  graph
  |> fontawesome_dice_d6({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dice_d6(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dice_d6(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dice_d6(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 627}, {50, 57}, opts)
  end
            
  @doc """
  Adds the dice-five icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dice-five

  ```
  graph
  |> fontawesome_dice_five({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dice_five(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dice_five(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dice_five(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 684}, {50, 57}, opts)
  end
            
  @doc """
  Adds the dice-four icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dice-four

  ```
  graph
  |> fontawesome_dice_four({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dice_four(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dice_four(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dice_four(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 741}, {50, 57}, opts)
  end
            
  @doc """
  Adds the dice-one icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dice-one

  ```
  graph
  |> fontawesome_dice_one({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dice_one(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dice_one(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dice_one(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 798}, {50, 57}, opts)
  end
            
  @doc """
  Adds the dice-six icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dice-six

  ```
  graph
  |> fontawesome_dice_six({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dice_six(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dice_six(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dice_six(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 855}, {50, 57}, opts)
  end
            
  @doc """
  Adds the dice-three icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dice-three

  ```
  graph
  |> fontawesome_dice_three({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dice_three(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dice_three(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dice_three(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the dice-two icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dice-two

  ```
  graph
  |> fontawesome_dice_two({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dice_two(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dice_two(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dice_two(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the dice icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dice

  ```
  graph
  |> fontawesome_dice({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dice(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dice(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dice(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the disease icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/disease

  ```
  graph
  |> fontawesome_disease({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_disease(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_disease(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_disease(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the display icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/display

  ```
  graph
  |> fontawesome_display({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_display(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_display(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_display(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 484}, {50, 44}, opts)
  end
            
  @doc """
  Adds the divide icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/divide

  ```
  graph
  |> fontawesome_divide({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_divide(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_divide(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_divide(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the dna icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dna

  ```
  graph
  |> fontawesome_dna({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dna(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dna(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dna(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the dog icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dog

  ```
  graph
  |> fontawesome_dog({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dog(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dog(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dog(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 528}, {50, 44}, opts)
  end
            
  @doc """
  Adds the dollar-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dollar-sign

  ```
  graph
  |> fontawesome_dollar_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dollar_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dollar_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dollar_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 380}, {50, 80}, opts)
  end
            
  @doc """
  Adds the dolly icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dolly

  ```
  graph
  |> fontawesome_dolly({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dolly(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dolly(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dolly(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 572}, {50, 44}, opts)
  end
            
  @doc """
  Adds the dong-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dong-sign

  ```
  graph
  |> fontawesome_dong_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dong_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dong_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dong_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 134}, {50, 67}, opts)
  end
            
  @doc """
  Adds the door-closed icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/door-closed

  ```
  graph
  |> fontawesome_door_closed({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_door_closed(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_door_closed(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_door_closed(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 616}, {50, 44}, opts)
  end
            
  @doc """
  Adds the door-open icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/door-open

  ```
  graph
  |> fontawesome_door_open({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_door_open(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_door_open(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_door_open(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 660}, {50, 44}, opts)
  end
            
  @doc """
  Adds the dove icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dove

  ```
  graph
  |> fontawesome_dove({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dove(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dove(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dove(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the down-left-and-up-right-to-center icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/down-left-and-up-right-to-center

  ```
  graph
  |> fontawesome_down_left_and_up_right_to_center({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_down_left_and_up_right_to_center(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_down_left_and_up_right_to_center(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_down_left_and_up_right_to_center(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the down-long icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/down-long

  ```
  graph
  |> fontawesome_down_long({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_down_long(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_down_long(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_down_long(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 380}, {50, 80}, opts)
  end
            
  @doc """
  Adds the download icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/download

  ```
  graph
  |> fontawesome_download({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_download(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_download(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_download(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the dragon icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dragon

  ```
  graph
  |> fontawesome_dragon({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dragon(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dragon(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dragon(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the draw-polygon icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/draw-polygon

  ```
  graph
  |> fontawesome_draw_polygon({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_draw_polygon(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_draw_polygon(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_draw_polygon(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the droplet-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/droplet-slash

  ```
  graph
  |> fontawesome_droplet_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_droplet_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_droplet_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_droplet_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the droplet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/droplet

  ```
  graph
  |> fontawesome_droplet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_droplet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_droplet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_droplet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 201}, {50, 67}, opts)
  end
            
  @doc """
  Adds the drum-steelpan icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/drum-steelpan

  ```
  graph
  |> fontawesome_drum_steelpan({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_drum_steelpan(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_drum_steelpan(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_drum_steelpan(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 704}, {50, 44}, opts)
  end
            
  @doc """
  Adds the drum icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/drum

  ```
  graph
  |> fontawesome_drum({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_drum(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_drum(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_drum(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the drumstick-bite icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/drumstick-bite

  ```
  graph
  |> fontawesome_drumstick_bite({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_drumstick_bite(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_drumstick_bite(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_drumstick_bite(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the dumbbell icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dumbbell

  ```
  graph
  |> fontawesome_dumbbell({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dumbbell(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dumbbell(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dumbbell(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the dumpster-fire icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dumpster-fire

  ```
  graph
  |> fontawesome_dumpster_fire({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dumpster_fire(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dumpster_fire(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dumpster_fire(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the dumpster icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dumpster

  ```
  graph
  |> fontawesome_dumpster({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dumpster(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dumpster(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dumpster(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 748}, {50, 44}, opts)
  end
            
  @doc """
  Adds the dungeon icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/dungeon

  ```
  graph
  |> fontawesome_dungeon({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_dungeon(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_dungeon(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_dungeon(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the e icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/e

  ```
  graph
  |> fontawesome_e({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_e(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_e(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_e(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 380}, {50, 80}, opts)
  end
            
  @doc """
  Adds the ear-deaf icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ear-deaf

  ```
  graph
  |> fontawesome_ear_deaf({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ear_deaf(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ear_deaf(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ear_deaf(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the ear-listen icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ear-listen

  ```
  graph
  |> fontawesome_ear_listen({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ear_listen(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ear_listen(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ear_listen(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the earth-africa icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/earth-africa

  ```
  graph
  |> fontawesome_earth_africa({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_earth_africa(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_earth_africa(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_earth_africa(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the earth-americas icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/earth-americas

  ```
  graph
  |> fontawesome_earth_americas({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_earth_americas(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_earth_americas(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_earth_americas(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the earth-asia icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/earth-asia

  ```
  graph
  |> fontawesome_earth_asia({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_earth_asia(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_earth_asia(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_earth_asia(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the earth-europe icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/earth-europe

  ```
  graph
  |> fontawesome_earth_europe({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_earth_europe(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_earth_europe(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_earth_europe(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the earth-oceania icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/earth-oceania

  ```
  graph
  |> fontawesome_earth_oceania({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_earth_oceania(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_earth_oceania(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_earth_oceania(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the egg icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/egg

  ```
  graph
  |> fontawesome_egg({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_egg(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_egg(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_egg(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 268}, {50, 67}, opts)
  end
            
  @doc """
  Adds the eject icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/eject

  ```
  graph
  |> fontawesome_eject({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_eject(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_eject(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_eject(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the elevator icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/elevator

  ```
  graph
  |> fontawesome_elevator({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_elevator(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_elevator(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_elevator(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the ellipsis-vertical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ellipsis-vertical

  ```
  graph
  |> fontawesome_ellipsis_vertical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ellipsis_vertical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ellipsis_vertical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ellipsis_vertical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 0}, {50, 200}, opts)
  end
            
  @doc """
  Adds the ellipsis icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ellipsis

  ```
  graph
  |> fontawesome_ellipsis({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ellipsis(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ellipsis(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ellipsis(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the envelope-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/envelope-circle-check

  ```
  graph
  |> fontawesome_envelope_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_envelope_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_envelope_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_envelope_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the envelope-open-text icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/envelope-open-text

  ```
  graph
  |> fontawesome_envelope_open_text({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_envelope_open_text(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_envelope_open_text(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_envelope_open_text(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the envelope-open icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/envelope-open

  ```
  graph
  |> fontawesome_envelope_open({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_envelope_open(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_envelope_open(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_envelope_open(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the envelope icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/envelope

  ```
  graph
  |> fontawesome_envelope({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_envelope(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_envelope(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_envelope(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the envelopes-bulk icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/envelopes-bulk

  ```
  graph
  |> fontawesome_envelopes_bulk({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_envelopes_bulk(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_envelopes_bulk(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_envelopes_bulk(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the equals icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/equals

  ```
  graph
  |> fontawesome_equals({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_equals(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_equals(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_equals(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the eraser icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/eraser

  ```
  graph
  |> fontawesome_eraser({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_eraser(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_eraser(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_eraser(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 792}, {50, 44}, opts)
  end
            
  @doc """
  Adds the ethernet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ethernet

  ```
  graph
  |> fontawesome_ethernet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ethernet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ethernet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ethernet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the euro-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/euro-sign

  ```
  graph
  |> fontawesome_euro_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_euro_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_euro_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_euro_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 380}, {50, 80}, opts)
  end
            
  @doc """
  Adds the exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/exclamation

  ```
  graph
  |> fontawesome_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 0}, {50, 200}, opts)
  end
            
  @doc """
  Adds the expand icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/expand

  ```
  graph
  |> fontawesome_expand({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_expand(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_expand(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_expand(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the explosion icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/explosion

  ```
  graph
  |> fontawesome_explosion({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_explosion(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_explosion(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_explosion(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 836}, {50, 44}, opts)
  end
            
  @doc """
  Adds the eye-dropper icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/eye-dropper

  ```
  graph
  |> fontawesome_eye_dropper({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_eye_dropper(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_eye_dropper(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_eye_dropper(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the eye-low-vision icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/eye-low-vision

  ```
  graph
  |> fontawesome_eye_low_vision({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_eye_low_vision(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_eye_low_vision(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_eye_low_vision(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the eye-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/eye-slash

  ```
  graph
  |> fontawesome_eye_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_eye_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_eye_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_eye_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the eye icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/eye

  ```
  graph
  |> fontawesome_eye({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_eye(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_eye(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_eye(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 880}, {50, 44}, opts)
  end
            
  @doc """
  Adds the f icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/f

  ```
  graph
  |> fontawesome_f({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_f(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_f(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_f(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 380}, {50, 80}, opts)
  end
            
  @doc """
  Adds the face-angry icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-angry

  ```
  graph
  |> fontawesome_face_angry({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_angry(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_angry(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_angry(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1273}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-dizzy icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-dizzy

  ```
  graph
  |> fontawesome_face_dizzy({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_dizzy(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_dizzy(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_dizzy(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 0}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-flushed icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-flushed

  ```
  graph
  |> fontawesome_face_flushed({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_flushed(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_flushed(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_flushed(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 50}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-frown-open icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-frown-open

  ```
  graph
  |> fontawesome_face_frown_open({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_frown_open(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_frown_open(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_frown_open(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-frown icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-frown

  ```
  graph
  |> fontawesome_face_frown({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_frown(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_frown(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_frown(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-grimace icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grimace

  ```
  graph
  |> fontawesome_face_grimace({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grimace(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grimace(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grimace(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-grin-beam-sweat icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grin-beam-sweat

  ```
  graph
  |> fontawesome_face_grin_beam_sweat({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grin_beam_sweat(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grin_beam_sweat(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grin_beam_sweat(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-grin-beam icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grin-beam

  ```
  graph
  |> fontawesome_face_grin_beam({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grin_beam(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grin_beam(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grin_beam(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 300}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-grin-hearts icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grin-hearts

  ```
  graph
  |> fontawesome_face_grin_hearts({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grin_hearts(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grin_hearts(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grin_hearts(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 350}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-grin-squint-tears icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grin-squint-tears

  ```
  graph
  |> fontawesome_face_grin_squint_tears({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grin_squint_tears(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grin_squint_tears(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grin_squint_tears(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 400}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-grin-squint icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grin-squint

  ```
  graph
  |> fontawesome_face_grin_squint({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grin_squint(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grin_squint(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grin_squint(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 450}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-grin-stars icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grin-stars

  ```
  graph
  |> fontawesome_face_grin_stars({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grin_stars(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grin_stars(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grin_stars(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 500}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-grin-tears icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grin-tears

  ```
  graph
  |> fontawesome_face_grin_tears({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grin_tears(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grin_tears(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grin_tears(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the face-grin-tongue-squint icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grin-tongue-squint

  ```
  graph
  |> fontawesome_face_grin_tongue_squint({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grin_tongue_squint(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grin_tongue_squint(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grin_tongue_squint(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 550}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-grin-tongue-wink icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grin-tongue-wink

  ```
  graph
  |> fontawesome_face_grin_tongue_wink({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grin_tongue_wink(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grin_tongue_wink(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grin_tongue_wink(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 600}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-grin-tongue icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grin-tongue

  ```
  graph
  |> fontawesome_face_grin_tongue({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grin_tongue(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grin_tongue(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grin_tongue(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 650}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-grin-wide icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grin-wide

  ```
  graph
  |> fontawesome_face_grin_wide({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grin_wide(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grin_wide(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grin_wide(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 700}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-grin-wink icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grin-wink

  ```
  graph
  |> fontawesome_face_grin_wink({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grin_wink(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grin_wink(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grin_wink(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 750}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-grin icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-grin

  ```
  graph
  |> fontawesome_face_grin({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_grin(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_grin(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_grin(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 800}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-kiss-beam icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-kiss-beam

  ```
  graph
  |> fontawesome_face_kiss_beam({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_kiss_beam(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_kiss_beam(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_kiss_beam(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 850}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-kiss-wink-heart icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-kiss-wink-heart

  ```
  graph
  |> fontawesome_face_kiss_wink_heart({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_kiss_wink_heart(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_kiss_wink_heart(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_kiss_wink_heart(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 900}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-kiss icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-kiss

  ```
  graph
  |> fontawesome_face_kiss({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_kiss(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_kiss(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_kiss(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 950}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-laugh-beam icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-laugh-beam

  ```
  graph
  |> fontawesome_face_laugh_beam({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_laugh_beam(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_laugh_beam(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_laugh_beam(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1000}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-laugh-squint icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-laugh-squint

  ```
  graph
  |> fontawesome_face_laugh_squint({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_laugh_squint(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_laugh_squint(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_laugh_squint(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1050}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-laugh-wink icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-laugh-wink

  ```
  graph
  |> fontawesome_face_laugh_wink({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_laugh_wink(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_laugh_wink(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_laugh_wink(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-laugh icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-laugh

  ```
  graph
  |> fontawesome_face_laugh({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_laugh(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_laugh(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_laugh(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-meh-blank icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-meh-blank

  ```
  graph
  |> fontawesome_face_meh_blank({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_meh_blank(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_meh_blank(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_meh_blank(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-meh icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-meh

  ```
  graph
  |> fontawesome_face_meh({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_meh(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_meh(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_meh(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-rolling-eyes icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-rolling-eyes

  ```
  graph
  |> fontawesome_face_rolling_eyes({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_rolling_eyes(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_rolling_eyes(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_rolling_eyes(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-sad-cry icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-sad-cry

  ```
  graph
  |> fontawesome_face_sad_cry({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_sad_cry(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_sad_cry(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_sad_cry(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-sad-tear icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-sad-tear

  ```
  graph
  |> fontawesome_face_sad_tear({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_sad_tear(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_sad_tear(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_sad_tear(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-smile-beam icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-smile-beam

  ```
  graph
  |> fontawesome_face_smile_beam({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_smile_beam(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_smile_beam(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_smile_beam(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-smile-wink icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-smile-wink

  ```
  graph
  |> fontawesome_face_smile_wink({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_smile_wink(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_smile_wink(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_smile_wink(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-smile icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-smile

  ```
  graph
  |> fontawesome_face_smile({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_smile(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_smile(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_smile(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-surprise icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-surprise

  ```
  graph
  |> fontawesome_face_surprise({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_surprise(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_surprise(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_surprise(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the face-tired icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/face-tired

  ```
  graph
  |> fontawesome_face_tired({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_face_tired(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_face_tired(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_face_tired(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the fan icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/fan

  ```
  graph
  |> fontawesome_fan({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_fan(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_fan(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_fan(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the faucet-drip icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/faucet-drip

  ```
  graph
  |> fontawesome_faucet_drip({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_faucet_drip(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_faucet_drip(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_faucet_drip(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the faucet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/faucet

  ```
  graph
  |> fontawesome_faucet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_faucet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_faucet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_faucet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the fax icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/fax

  ```
  graph
  |> fontawesome_fax({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_fax(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_fax(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_fax(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the feather-pointed icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/feather-pointed

  ```
  graph
  |> fontawesome_feather_pointed({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_feather_pointed(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_feather_pointed(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_feather_pointed(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the feather icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/feather

  ```
  graph
  |> fontawesome_feather({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_feather(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_feather(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_feather(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the ferry icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ferry

  ```
  graph
  |> fontawesome_ferry({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ferry(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ferry(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ferry(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 924}, {50, 44}, opts)
  end
            
  @doc """
  Adds the file-arrow-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-arrow-down

  ```
  graph
  |> fontawesome_file_arrow_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_arrow_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_arrow_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_arrow_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 335}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-arrow-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-arrow-up

  ```
  graph
  |> fontawesome_file_arrow_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_arrow_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_arrow_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_arrow_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 402}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-audio icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-audio

  ```
  graph
  |> fontawesome_file_audio({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_audio(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_audio(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_audio(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 469}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-circle-check

  ```
  graph
  |> fontawesome_file_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 968}, {50, 44}, opts)
  end
            
  @doc """
  Adds the file-circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-circle-exclamation

  ```
  graph
  |> fontawesome_file_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1012}, {50, 44}, opts)
  end
            
  @doc """
  Adds the file-circle-minus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-circle-minus

  ```
  graph
  |> fontawesome_file_circle_minus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_circle_minus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_circle_minus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_circle_minus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1056}, {50, 44}, opts)
  end
            
  @doc """
  Adds the file-circle-plus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-circle-plus

  ```
  graph
  |> fontawesome_file_circle_plus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_circle_plus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_circle_plus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_circle_plus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1100}, {50, 44}, opts)
  end
            
  @doc """
  Adds the file-circle-question icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-circle-question

  ```
  graph
  |> fontawesome_file_circle_question({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_circle_question(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_circle_question(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_circle_question(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1144}, {50, 44}, opts)
  end
            
  @doc """
  Adds the file-circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-circle-xmark

  ```
  graph
  |> fontawesome_file_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1188}, {50, 44}, opts)
  end
            
  @doc """
  Adds the file-code icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-code

  ```
  graph
  |> fontawesome_file_code({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_code(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_code(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_code(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 536}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-contract icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-contract

  ```
  graph
  |> fontawesome_file_contract({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_contract(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_contract(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_contract(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 603}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-csv icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-csv

  ```
  graph
  |> fontawesome_file_csv({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_csv(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_csv(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_csv(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the file-excel icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-excel

  ```
  graph
  |> fontawesome_file_excel({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_excel(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_excel(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_excel(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 0}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-export icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-export

  ```
  graph
  |> fontawesome_file_export({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_export(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_export(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_export(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1232}, {50, 44}, opts)
  end
            
  @doc """
  Adds the file-image icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-image

  ```
  graph
  |> fontawesome_file_image({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_image(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_image(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_image(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 67}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-import icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-import

  ```
  graph
  |> fontawesome_file_import({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_import(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_import(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_import(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the file-invoice-dollar icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-invoice-dollar

  ```
  graph
  |> fontawesome_file_invoice_dollar({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_invoice_dollar(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_invoice_dollar(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_invoice_dollar(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 134}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-invoice icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-invoice

  ```
  graph
  |> fontawesome_file_invoice({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_invoice(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_invoice(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_invoice(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 201}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-lines icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-lines

  ```
  graph
  |> fontawesome_file_lines({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_lines(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_lines(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_lines(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 268}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-medical

  ```
  graph
  |> fontawesome_file_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 335}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-pdf icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-pdf

  ```
  graph
  |> fontawesome_file_pdf({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_pdf(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_pdf(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_pdf(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the file-pen icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-pen

  ```
  graph
  |> fontawesome_file_pen({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_pen(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_pen(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_pen(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1276}, {50, 44}, opts)
  end
            
  @doc """
  Adds the file-powerpoint icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-powerpoint

  ```
  graph
  |> fontawesome_file_powerpoint({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_powerpoint(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_powerpoint(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_powerpoint(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 402}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-prescription icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-prescription

  ```
  graph
  |> fontawesome_file_prescription({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_prescription(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_prescription(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_prescription(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 469}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-shield icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-shield

  ```
  graph
  |> fontawesome_file_shield({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_shield(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_shield(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_shield(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1320}, {50, 44}, opts)
  end
            
  @doc """
  Adds the file-signature icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-signature

  ```
  graph
  |> fontawesome_file_signature({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_signature(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_signature(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_signature(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1364}, {50, 44}, opts)
  end
            
  @doc """
  Adds the file-video icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-video

  ```
  graph
  |> fontawesome_file_video({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_video(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_video(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_video(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 536}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-waveform icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-waveform

  ```
  graph
  |> fontawesome_file_waveform({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_waveform(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_waveform(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_waveform(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the file-word icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-word

  ```
  graph
  |> fontawesome_file_word({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_word(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_word(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_word(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 603}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file-zipper icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file-zipper

  ```
  graph
  |> fontawesome_file_zipper({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file_zipper(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file_zipper(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file_zipper(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the file icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/file

  ```
  graph
  |> fontawesome_file({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_file(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_file(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_file(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the fill-drip icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/fill-drip

  ```
  graph
  |> fontawesome_fill_drip({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_fill_drip(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_fill_drip(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_fill_drip(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1408}, {50, 44}, opts)
  end
            
  @doc """
  Adds the fill icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/fill

  ```
  graph
  |> fontawesome_fill({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_fill(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_fill(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_fill(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the film icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/film

  ```
  graph
  |> fontawesome_film({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_film(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_film(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_film(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the filter-circle-dollar icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/filter-circle-dollar

  ```
  graph
  |> fontawesome_filter_circle_dollar({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_filter_circle_dollar(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_filter_circle_dollar(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_filter_circle_dollar(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1452}, {50, 44}, opts)
  end
            
  @doc """
  Adds the filter-circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/filter-circle-xmark

  ```
  graph
  |> fontawesome_filter_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_filter_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_filter_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_filter_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1496}, {50, 44}, opts)
  end
            
  @doc """
  Adds the filter icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/filter

  ```
  graph
  |> fontawesome_filter({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_filter(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_filter(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_filter(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the fingerprint icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/fingerprint

  ```
  graph
  |> fontawesome_fingerprint({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_fingerprint(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_fingerprint(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_fingerprint(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the fire-burner icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/fire-burner

  ```
  graph
  |> fontawesome_fire_burner({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_fire_burner(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_fire_burner(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_fire_burner(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the fire-extinguisher icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/fire-extinguisher

  ```
  graph
  |> fontawesome_fire_extinguisher({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_fire_extinguisher(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_fire_extinguisher(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_fire_extinguisher(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the fire-flame-curved icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/fire-flame-curved

  ```
  graph
  |> fontawesome_fire_flame_curved({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_fire_flame_curved(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_fire_flame_curved(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_fire_flame_curved(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the fire-flame-simple icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/fire-flame-simple

  ```
  graph
  |> fontawesome_fire_flame_simple({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_fire_flame_simple(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_fire_flame_simple(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_fire_flame_simple(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the fire icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/fire

  ```
  graph
  |> fontawesome_fire({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_fire(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_fire(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_fire(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the fish-fins icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/fish-fins

  ```
  graph
  |> fontawesome_fish_fins({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_fish_fins(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_fish_fins(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_fish_fins(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1540}, {50, 44}, opts)
  end
            
  @doc """
  Adds the fish icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/fish

  ```
  graph
  |> fontawesome_fish({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_fish(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_fish(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_fish(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the flag-checkered icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/flag-checkered

  ```
  graph
  |> fontawesome_flag_checkered({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_flag_checkered(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_flag_checkered(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_flag_checkered(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the flag-usa icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/flag-usa

  ```
  graph
  |> fontawesome_flag_usa({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_flag_usa(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_flag_usa(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_flag_usa(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the flag icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/flag

  ```
  graph
  |> fontawesome_flag({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_flag(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_flag(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_flag(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the flask-vial icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/flask-vial

  ```
  graph
  |> fontawesome_flask_vial({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_flask_vial(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_flask_vial(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_flask_vial(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the flask icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/flask

  ```
  graph
  |> fontawesome_flask({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_flask(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_flask(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_flask(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the floppy-disk icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/floppy-disk

  ```
  graph
  |> fontawesome_floppy_disk({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_floppy_disk(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_floppy_disk(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_floppy_disk(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the florin-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/florin-sign

  ```
  graph
  |> fontawesome_florin_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_florin_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_florin_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_florin_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the folder-closed icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/folder-closed

  ```
  graph
  |> fontawesome_folder_closed({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_folder_closed(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_folder_closed(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_folder_closed(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the folder-minus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/folder-minus

  ```
  graph
  |> fontawesome_folder_minus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_folder_minus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_folder_minus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_folder_minus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the folder-open icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/folder-open

  ```
  graph
  |> fontawesome_folder_open({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_folder_open(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_folder_open(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_folder_open(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the folder-plus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/folder-plus

  ```
  graph
  |> fontawesome_folder_plus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_folder_plus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_folder_plus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_folder_plus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the folder-tree icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/folder-tree

  ```
  graph
  |> fontawesome_folder_tree({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_folder_tree(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_folder_tree(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_folder_tree(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the folder icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/folder

  ```
  graph
  |> fontawesome_folder({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_folder(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_folder(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_folder(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the font-awesome icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/font-awesome

  ```
  graph
  |> fontawesome_font_awesome({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_font_awesome(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_font_awesome(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_font_awesome(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the font icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/font

  ```
  graph
  |> fontawesome_font({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_font(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_font(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_font(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the football icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/football

  ```
  graph
  |> fontawesome_football({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_football(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_football(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_football(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1323}, {50, 50}, opts)
  end
            
  @doc """
  Adds the forward-fast icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/forward-fast

  ```
  graph
  |> fontawesome_forward_fast({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_forward_fast(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_forward_fast(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_forward_fast(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 0}, {50, 50}, opts)
  end
            
  @doc """
  Adds the forward-step icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/forward-step

  ```
  graph
  |> fontawesome_forward_step({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_forward_step(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_forward_step(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_forward_step(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 380}, {50, 80}, opts)
  end
            
  @doc """
  Adds the forward icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/forward

  ```
  graph
  |> fontawesome_forward({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_forward(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_forward(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_forward(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 50}, {50, 50}, opts)
  end
            
  @doc """
  Adds the franc-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/franc-sign

  ```
  graph
  |> fontawesome_franc_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_franc_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_franc_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_franc_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 380}, {50, 80}, opts)
  end
            
  @doc """
  Adds the frog icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/frog

  ```
  graph
  |> fontawesome_frog({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_frog(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_frog(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_frog(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the futbol icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/futbol

  ```
  graph
  |> fontawesome_futbol({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_futbol(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_futbol(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_futbol(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the g icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/g

  ```
  graph
  |> fontawesome_g({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_g(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_g(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_g(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the gamepad icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gamepad

  ```
  graph
  |> fontawesome_gamepad({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gamepad(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gamepad(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gamepad(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the gas-pump icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gas-pump

  ```
  graph
  |> fontawesome_gas_pump({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gas_pump(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gas_pump(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gas_pump(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the gauge-high icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gauge-high

  ```
  graph
  |> fontawesome_gauge_high({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gauge_high(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gauge_high(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gauge_high(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the gauge-simple-high icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gauge-simple-high

  ```
  graph
  |> fontawesome_gauge_simple_high({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gauge_simple_high(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gauge_simple_high(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gauge_simple_high(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the gauge-simple icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gauge-simple

  ```
  graph
  |> fontawesome_gauge_simple({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gauge_simple(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gauge_simple(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gauge_simple(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 300}, {50, 50}, opts)
  end
            
  @doc """
  Adds the gauge icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gauge

  ```
  graph
  |> fontawesome_gauge({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gauge(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gauge(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gauge(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 350}, {50, 50}, opts)
  end
            
  @doc """
  Adds the gavel icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gavel

  ```
  graph
  |> fontawesome_gavel({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gavel(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gavel(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gavel(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 400}, {50, 50}, opts)
  end
            
  @doc """
  Adds the gear icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gear

  ```
  graph
  |> fontawesome_gear({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gear(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gear(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gear(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 450}, {50, 50}, opts)
  end
            
  @doc """
  Adds the gears icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gears

  ```
  graph
  |> fontawesome_gears({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gears(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gears(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gears(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1749}, {50, 40}, opts)
  end
            
  @doc """
  Adds the gem icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gem

  ```
  graph
  |> fontawesome_gem({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gem(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gem(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gem(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 500}, {50, 50}, opts)
  end
            
  @doc """
  Adds the genderless icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/genderless

  ```
  graph
  |> fontawesome_genderless({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_genderless(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_genderless(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_genderless(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the ghost icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ghost

  ```
  graph
  |> fontawesome_ghost({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ghost(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ghost(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ghost(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the gift icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gift

  ```
  graph
  |> fontawesome_gift({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gift(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gift(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gift(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 550}, {50, 50}, opts)
  end
            
  @doc """
  Adds the gifts icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gifts

  ```
  graph
  |> fontawesome_gifts({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gifts(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gifts(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gifts(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 0}, {50, 40}, opts)
  end
            
  @doc """
  Adds the glass-water-droplet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/glass-water-droplet

  ```
  graph
  |> fontawesome_glass_water_droplet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_glass_water_droplet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_glass_water_droplet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_glass_water_droplet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the glass-water icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/glass-water

  ```
  graph
  |> fontawesome_glass_water({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_glass_water(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_glass_water(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_glass_water(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the glasses icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/glasses

  ```
  graph
  |> fontawesome_glasses({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_glasses(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_glasses(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_glasses(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the globe icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/globe

  ```
  graph
  |> fontawesome_globe({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_globe(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_globe(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_globe(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 600}, {50, 50}, opts)
  end
            
  @doc """
  Adds the golf-ball-tee icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/golf-ball-tee

  ```
  graph
  |> fontawesome_golf_ball_tee({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_golf_ball_tee(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_golf_ball_tee(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_golf_ball_tee(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the gopuram icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gopuram

  ```
  graph
  |> fontawesome_gopuram({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gopuram(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gopuram(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gopuram(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 650}, {50, 50}, opts)
  end
            
  @doc """
  Adds the graduation-cap icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/graduation-cap

  ```
  graph
  |> fontawesome_graduation_cap({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_graduation_cap(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_graduation_cap(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_graduation_cap(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 40}, {50, 40}, opts)
  end
            
  @doc """
  Adds the greater-than-equal icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/greater-than-equal

  ```
  graph
  |> fontawesome_greater_than_equal({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_greater_than_equal(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_greater_than_equal(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_greater_than_equal(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the greater-than icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/greater-than

  ```
  graph
  |> fontawesome_greater_than({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_greater_than(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_greater_than(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_greater_than(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the grip-lines-vertical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/grip-lines-vertical

  ```
  graph
  |> fontawesome_grip_lines_vertical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_grip_lines_vertical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_grip_lines_vertical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_grip_lines_vertical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 0}, {50, 133}, opts)
  end
            
  @doc """
  Adds the grip-lines icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/grip-lines

  ```
  graph
  |> fontawesome_grip_lines({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_grip_lines(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_grip_lines(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_grip_lines(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the grip-vertical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/grip-vertical

  ```
  graph
  |> fontawesome_grip_vertical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_grip_vertical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_grip_vertical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_grip_vertical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 380}, {50, 80}, opts)
  end
            
  @doc """
  Adds the grip icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/grip

  ```
  graph
  |> fontawesome_grip({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_grip(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_grip(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_grip(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 945}, {50, 57}, opts)
  end
            
  @doc """
  Adds the group-arrows-rotate icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/group-arrows-rotate

  ```
  graph
  |> fontawesome_group_arrows_rotate({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_group_arrows_rotate(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_group_arrows_rotate(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_group_arrows_rotate(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 700}, {50, 50}, opts)
  end
            
  @doc """
  Adds the guarani-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/guarani-sign

  ```
  graph
  |> fontawesome_guarani_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_guarani_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_guarani_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_guarani_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the guitar icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/guitar

  ```
  graph
  |> fontawesome_guitar({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_guitar(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_guitar(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_guitar(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 750}, {50, 50}, opts)
  end
            
  @doc """
  Adds the gun icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/gun

  ```
  graph
  |> fontawesome_gun({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_gun(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_gun(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_gun(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the h icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/h

  ```
  graph
  |> fontawesome_h({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_h(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_h(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_h(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the hammer icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hammer

  ```
  graph
  |> fontawesome_hammer({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hammer(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hammer(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hammer(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hamsa icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hamsa

  ```
  graph
  |> fontawesome_hamsa({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hamsa(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hamsa(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hamsa(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 800}, {50, 50}, opts)
  end
            
  @doc """
  Adds the hand-back-fist icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-back-fist

  ```
  graph
  |> fontawesome_hand_back_fist({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_back_fist(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_back_fist(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_back_fist(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 0}, {50, 57}, opts)
  end
            
  @doc """
  Adds the hand-dots icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-dots

  ```
  graph
  |> fontawesome_hand_dots({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_dots(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_dots(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_dots(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 850}, {50, 50}, opts)
  end
            
  @doc """
  Adds the hand-fist icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-fist

  ```
  graph
  |> fontawesome_hand_fist({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_fist(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_fist(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_fist(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 57}, {50, 57}, opts)
  end
            
  @doc """
  Adds the hand-holding-dollar icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-holding-dollar

  ```
  graph
  |> fontawesome_hand_holding_dollar({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_holding_dollar(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_holding_dollar(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_holding_dollar(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hand-holding-droplet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-holding-droplet

  ```
  graph
  |> fontawesome_hand_holding_droplet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_holding_droplet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_holding_droplet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_holding_droplet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hand-holding-hand icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-holding-hand

  ```
  graph
  |> fontawesome_hand_holding_hand({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_holding_hand(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_holding_hand(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_holding_hand(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hand-holding-heart icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-holding-heart

  ```
  graph
  |> fontawesome_hand_holding_heart({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_holding_heart(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_holding_heart(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_holding_heart(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hand-holding-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-holding-medical

  ```
  graph
  |> fontawesome_hand_holding_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_holding_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_holding_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_holding_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hand-holding icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-holding

  ```
  graph
  |> fontawesome_hand_holding({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_holding(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_holding(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_holding(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hand-lizard icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-lizard

  ```
  graph
  |> fontawesome_hand_lizard({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_lizard(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_lizard(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_lizard(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 900}, {50, 50}, opts)
  end
            
  @doc """
  Adds the hand-middle-finger icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-middle-finger

  ```
  graph
  |> fontawesome_hand_middle_finger({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_middle_finger(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_middle_finger(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_middle_finger(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 114}, {50, 57}, opts)
  end
            
  @doc """
  Adds the hand-peace icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-peace

  ```
  graph
  |> fontawesome_hand_peace({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_peace(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_peace(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_peace(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 950}, {50, 50}, opts)
  end
            
  @doc """
  Adds the hand-point-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-point-down

  ```
  graph
  |> fontawesome_hand_point_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_point_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_point_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_point_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the hand-point-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-point-left

  ```
  graph
  |> fontawesome_hand_point_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_point_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_point_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_point_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1000}, {50, 50}, opts)
  end
            
  @doc """
  Adds the hand-point-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-point-right

  ```
  graph
  |> fontawesome_hand_point_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_point_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_point_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_point_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1050}, {50, 50}, opts)
  end
            
  @doc """
  Adds the hand-point-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-point-up

  ```
  graph
  |> fontawesome_hand_point_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_point_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_point_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_point_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the hand-pointer icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-pointer

  ```
  graph
  |> fontawesome_hand_pointer({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_pointer(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_pointer(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_pointer(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 171}, {50, 57}, opts)
  end
            
  @doc """
  Adds the hand-scissors icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-scissors

  ```
  graph
  |> fontawesome_hand_scissors({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_scissors(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_scissors(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_scissors(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the hand-sparkles icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-sparkles

  ```
  graph
  |> fontawesome_hand_sparkles({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_sparkles(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_sparkles(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_sparkles(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 80}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hand-spock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand-spock

  ```
  graph
  |> fontawesome_hand_spock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand_spock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand_spock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand_spock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hand icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hand

  ```
  graph
  |> fontawesome_hand({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hand(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hand(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hand(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the handcuffs icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/handcuffs

  ```
  graph
  |> fontawesome_handcuffs({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_handcuffs(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_handcuffs(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_handcuffs(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 120}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hands-asl-interpreting icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hands-asl-interpreting

  ```
  graph
  |> fontawesome_hands_asl_interpreting({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hands_asl_interpreting(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hands_asl_interpreting(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hands_asl_interpreting(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 160}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hands-bound icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hands-bound

  ```
  graph
  |> fontawesome_hands_bound({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hands_bound(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hands_bound(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hands_bound(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 200}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hands-bubbles icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hands-bubbles

  ```
  graph
  |> fontawesome_hands_bubbles({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hands_bubbles(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hands_bubbles(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hands_bubbles(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hands-clapping icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hands-clapping

  ```
  graph
  |> fontawesome_hands_clapping({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hands_clapping(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hands_clapping(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hands_clapping(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the hands-holding-child icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hands-holding-child

  ```
  graph
  |> fontawesome_hands_holding_child({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hands_holding_child(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hands_holding_child(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hands_holding_child(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 240}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hands-holding-circle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hands-holding-circle

  ```
  graph
  |> fontawesome_hands_holding_circle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hands_holding_circle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hands_holding_circle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hands_holding_circle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 280}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hands-holding icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hands-holding

  ```
  graph
  |> fontawesome_hands_holding({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hands_holding(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hands_holding(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hands_holding(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 320}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hands-praying icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hands-praying

  ```
  graph
  |> fontawesome_hands_praying({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hands_praying(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hands_praying(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hands_praying(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 360}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hands icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hands

  ```
  graph
  |> fontawesome_hands({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hands(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hands(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hands(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the handshake-angle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/handshake-angle

  ```
  graph
  |> fontawesome_handshake_angle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_handshake_angle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_handshake_angle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_handshake_angle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 400}, {50, 40}, opts)
  end
            
  @doc """
  Adds the handshake-simple-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/handshake-simple-slash

  ```
  graph
  |> fontawesome_handshake_simple_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_handshake_simple_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_handshake_simple_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_handshake_simple_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 440}, {50, 40}, opts)
  end
            
  @doc """
  Adds the handshake-simple icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/handshake-simple

  ```
  graph
  |> fontawesome_handshake_simple({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_handshake_simple(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_handshake_simple(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_handshake_simple(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 480}, {50, 40}, opts)
  end
            
  @doc """
  Adds the handshake-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/handshake-slash

  ```
  graph
  |> fontawesome_handshake_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_handshake_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_handshake_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_handshake_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 520}, {50, 40}, opts)
  end
            
  @doc """
  Adds the handshake icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/handshake

  ```
  graph
  |> fontawesome_handshake({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_handshake(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_handshake(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_handshake(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 560}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hanukiah icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hanukiah

  ```
  graph
  |> fontawesome_hanukiah({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hanukiah(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hanukiah(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hanukiah(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 600}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hard-drive icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hard-drive

  ```
  graph
  |> fontawesome_hard_drive({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hard_drive(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hard_drive(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hard_drive(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the hashtag icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hashtag

  ```
  graph
  |> fontawesome_hashtag({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hashtag(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hashtag(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hashtag(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 228}, {50, 57}, opts)
  end
            
  @doc """
  Adds the hat-cowboy-side icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hat-cowboy-side

  ```
  graph
  |> fontawesome_hat_cowboy_side({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hat_cowboy_side(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hat_cowboy_side(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hat_cowboy_side(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 640}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hat-cowboy icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hat-cowboy

  ```
  graph
  |> fontawesome_hat_cowboy({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hat_cowboy(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hat_cowboy(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hat_cowboy(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 680}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hat-wizard icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hat-wizard

  ```
  graph
  |> fontawesome_hat_wizard({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hat_wizard(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hat_wizard(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hat_wizard(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1300}, {50, 50}, opts)
  end
            
  @doc """
  Adds the head-side-cough-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/head-side-cough-slash

  ```
  graph
  |> fontawesome_head_side_cough_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_head_side_cough_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_head_side_cough_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_head_side_cough_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 720}, {50, 40}, opts)
  end
            
  @doc """
  Adds the head-side-cough icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/head-side-cough

  ```
  graph
  |> fontawesome_head_side_cough({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_head_side_cough(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_head_side_cough(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_head_side_cough(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 760}, {50, 40}, opts)
  end
            
  @doc """
  Adds the head-side-mask icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/head-side-mask

  ```
  graph
  |> fontawesome_head_side_mask({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_head_side_mask(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_head_side_mask(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_head_side_mask(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the head-side-virus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/head-side-virus

  ```
  graph
  |> fontawesome_head_side_virus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_head_side_virus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_head_side_virus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_head_side_virus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the heading icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/heading

  ```
  graph
  |> fontawesome_heading({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_heading(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_heading(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_heading(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 285}, {50, 57}, opts)
  end
            
  @doc """
  Adds the headphones-simple icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/headphones-simple

  ```
  graph
  |> fontawesome_headphones_simple({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_headphones_simple(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_headphones_simple(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_headphones_simple(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the headphones icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/headphones

  ```
  graph
  |> fontawesome_headphones({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_headphones(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_headphones(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_headphones(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the headset icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/headset

  ```
  graph
  |> fontawesome_headset({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_headset(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_headset(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_headset(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the heart-circle-bolt icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/heart-circle-bolt

  ```
  graph
  |> fontawesome_heart_circle_bolt({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_heart_circle_bolt(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_heart_circle_bolt(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_heart_circle_bolt(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the heart-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/heart-circle-check

  ```
  graph
  |> fontawesome_heart_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_heart_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_heart_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_heart_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the heart-circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/heart-circle-exclamation

  ```
  graph
  |> fontawesome_heart_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_heart_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_heart_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_heart_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the heart-circle-minus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/heart-circle-minus

  ```
  graph
  |> fontawesome_heart_circle_minus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_heart_circle_minus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_heart_circle_minus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_heart_circle_minus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the heart-circle-plus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/heart-circle-plus

  ```
  graph
  |> fontawesome_heart_circle_plus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_heart_circle_plus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_heart_circle_plus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_heart_circle_plus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the heart-circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/heart-circle-xmark

  ```
  graph
  |> fontawesome_heart_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_heart_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_heart_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_heart_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the heart-crack icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/heart-crack

  ```
  graph
  |> fontawesome_heart_crack({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_heart_crack(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_heart_crack(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_heart_crack(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the heart-pulse icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/heart-pulse

  ```
  graph
  |> fontawesome_heart_pulse({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_heart_pulse(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_heart_pulse(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_heart_pulse(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the heart icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/heart

  ```
  graph
  |> fontawesome_heart({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_heart(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_heart(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_heart(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the helicopter-symbol icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/helicopter-symbol

  ```
  graph
  |> fontawesome_helicopter_symbol({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_helicopter_symbol(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_helicopter_symbol(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_helicopter_symbol(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the helicopter icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/helicopter

  ```
  graph
  |> fontawesome_helicopter({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_helicopter(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_helicopter(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_helicopter(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 800}, {50, 40}, opts)
  end
            
  @doc """
  Adds the helmet-safety icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/helmet-safety

  ```
  graph
  |> fontawesome_helmet_safety({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_helmet_safety(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_helmet_safety(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_helmet_safety(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the helmet-un icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/helmet-un

  ```
  graph
  |> fontawesome_helmet_un({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_helmet_un(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_helmet_un(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_helmet_un(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the highlighter icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/highlighter

  ```
  graph
  |> fontawesome_highlighter({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_highlighter(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_highlighter(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_highlighter(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hill-avalanche icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hill-avalanche

  ```
  graph
  |> fontawesome_hill_avalanche({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hill_avalanche(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hill_avalanche(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hill_avalanche(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hill-rockslide icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hill-rockslide

  ```
  graph
  |> fontawesome_hill_rockslide({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hill_rockslide(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hill_rockslide(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hill_rockslide(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hippo icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hippo

  ```
  graph
  |> fontawesome_hippo({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hippo(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hippo(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hippo(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 840}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hockey-puck icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hockey-puck

  ```
  graph
  |> fontawesome_hockey_puck({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hockey_puck(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hockey_puck(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hockey_puck(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the holly-berry icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/holly-berry

  ```
  graph
  |> fontawesome_holly_berry({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_holly_berry(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_holly_berry(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_holly_berry(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the horse-head icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/horse-head

  ```
  graph
  |> fontawesome_horse_head({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_horse_head(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_horse_head(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_horse_head(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 880}, {50, 40}, opts)
  end
            
  @doc """
  Adds the horse icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/horse

  ```
  graph
  |> fontawesome_horse({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_horse(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_horse(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_horse(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hospital-user icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hospital-user

  ```
  graph
  |> fontawesome_hospital_user({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hospital_user(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hospital_user(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hospital_user(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hospital icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hospital

  ```
  graph
  |> fontawesome_hospital({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hospital(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hospital(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hospital(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 920}, {50, 40}, opts)
  end
            
  @doc """
  Adds the hot-tub-person icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hot-tub-person

  ```
  graph
  |> fontawesome_hot_tub_person({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hot_tub_person(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hot_tub_person(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hot_tub_person(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the hotdog icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hotdog

  ```
  graph
  |> fontawesome_hotdog({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hotdog(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hotdog(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hotdog(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the hotel icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hotel

  ```
  graph
  |> fontawesome_hotel({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hotel(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hotel(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hotel(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the hourglass-end icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hourglass-end

  ```
  graph
  |> fontawesome_hourglass_end({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hourglass_end(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hourglass_end(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hourglass_end(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 687}, {50, 67}, opts)
  end
            
  @doc """
  Adds the hourglass-half icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hourglass-half

  ```
  graph
  |> fontawesome_hourglass_half({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hourglass_half(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hourglass_half(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hourglass_half(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 0}, {50, 67}, opts)
  end
            
  @doc """
  Adds the hourglass-start icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hourglass-start

  ```
  graph
  |> fontawesome_hourglass_start({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hourglass_start(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hourglass_start(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hourglass_start(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 67}, {50, 67}, opts)
  end
            
  @doc """
  Adds the hourglass icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hourglass

  ```
  graph
  |> fontawesome_hourglass({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hourglass(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hourglass(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hourglass(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 134}, {50, 67}, opts)
  end
            
  @doc """
  Adds the house-chimney-crack icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-chimney-crack

  ```
  graph
  |> fontawesome_house_chimney_crack({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_chimney_crack(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_chimney_crack(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_chimney_crack(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the house-chimney-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-chimney-medical

  ```
  graph
  |> fontawesome_house_chimney_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_chimney_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_chimney_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_chimney_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the house-chimney-user icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-chimney-user

  ```
  graph
  |> fontawesome_house_chimney_user({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_chimney_user(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_chimney_user(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_chimney_user(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the house-chimney-window icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-chimney-window

  ```
  graph
  |> fontawesome_house_chimney_window({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_chimney_window(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_chimney_window(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_chimney_window(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the house-chimney icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-chimney

  ```
  graph
  |> fontawesome_house_chimney({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_chimney(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_chimney(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_chimney(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1617}, {50, 44}, opts)
  end
            
  @doc """
  Adds the house-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-circle-check

  ```
  graph
  |> fontawesome_house_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 960}, {50, 40}, opts)
  end
            
  @doc """
  Adds the house-circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-circle-exclamation

  ```
  graph
  |> fontawesome_house_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1000}, {50, 40}, opts)
  end
            
  @doc """
  Adds the house-circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-circle-xmark

  ```
  graph
  |> fontawesome_house_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1040}, {50, 40}, opts)
  end
            
  @doc """
  Adds the house-crack icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-crack

  ```
  graph
  |> fontawesome_house_crack({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_crack(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_crack(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_crack(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 0}, {50, 44}, opts)
  end
            
  @doc """
  Adds the house-fire icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-fire

  ```
  graph
  |> fontawesome_house_fire({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_fire(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_fire(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_fire(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1080}, {50, 40}, opts)
  end
            
  @doc """
  Adds the house-flag icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-flag

  ```
  graph
  |> fontawesome_house_flag({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_flag(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_flag(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_flag(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1120}, {50, 40}, opts)
  end
            
  @doc """
  Adds the house-flood-water-circle-arrow-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-flood-water-circle-arrow-right

  ```
  graph
  |> fontawesome_house_flood_water_circle_arrow_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_flood_water_circle_arrow_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_flood_water_circle_arrow_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_flood_water_circle_arrow_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1160}, {50, 40}, opts)
  end
            
  @doc """
  Adds the house-flood-water icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-flood-water

  ```
  graph
  |> fontawesome_house_flood_water({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_flood_water(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_flood_water(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_flood_water(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 44}, {50, 44}, opts)
  end
            
  @doc """
  Adds the house-laptop icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-laptop

  ```
  graph
  |> fontawesome_house_laptop({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_laptop(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_laptop(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_laptop(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1200}, {50, 40}, opts)
  end
            
  @doc """
  Adds the house-lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-lock

  ```
  graph
  |> fontawesome_house_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1240}, {50, 40}, opts)
  end
            
  @doc """
  Adds the house-medical-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-medical-circle-check

  ```
  graph
  |> fontawesome_house_medical_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_medical_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_medical_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_medical_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1280}, {50, 40}, opts)
  end
            
  @doc """
  Adds the house-medical-circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-medical-circle-exclamation

  ```
  graph
  |> fontawesome_house_medical_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_medical_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_medical_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_medical_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1320}, {50, 40}, opts)
  end
            
  @doc """
  Adds the house-medical-circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-medical-circle-xmark

  ```
  graph
  |> fontawesome_house_medical_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_medical_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_medical_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_medical_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1360}, {50, 40}, opts)
  end
            
  @doc """
  Adds the house-medical-flag icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-medical-flag

  ```
  graph
  |> fontawesome_house_medical_flag({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_medical_flag(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_medical_flag(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_medical_flag(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1400}, {50, 40}, opts)
  end
            
  @doc """
  Adds the house-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-medical

  ```
  graph
  |> fontawesome_house_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 88}, {50, 44}, opts)
  end
            
  @doc """
  Adds the house-signal icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-signal

  ```
  graph
  |> fontawesome_house_signal({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_signal(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_signal(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_signal(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 132}, {50, 44}, opts)
  end
            
  @doc """
  Adds the house-tsunami icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-tsunami

  ```
  graph
  |> fontawesome_house_tsunami({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_tsunami(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_tsunami(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_tsunami(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 176}, {50, 44}, opts)
  end
            
  @doc """
  Adds the house-user icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house-user

  ```
  graph
  |> fontawesome_house_user({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house_user(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house_user(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house_user(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 220}, {50, 44}, opts)
  end
            
  @doc """
  Adds the house icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/house

  ```
  graph
  |> fontawesome_house({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_house(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_house(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_house(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 264}, {50, 44}, opts)
  end
            
  @doc """
  Adds the hryvnia-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hryvnia-sign

  ```
  graph
  |> fontawesome_hryvnia_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hryvnia_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hryvnia_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hryvnia_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 201}, {50, 67}, opts)
  end
            
  @doc """
  Adds the hurricane icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/hurricane

  ```
  graph
  |> fontawesome_hurricane({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_hurricane(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_hurricane(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_hurricane(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 268}, {50, 67}, opts)
  end
            
  @doc """
  Adds the i-cursor icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/i-cursor

  ```
  graph
  |> fontawesome_i_cursor({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_i_cursor(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_i_cursor(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_i_cursor(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 100}, {50, 100}, opts)
  end
            
  @doc """
  Adds the i icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/i

  ```
  graph
  |> fontawesome_i({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_i(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_i(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_i(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 0}, {50, 80}, opts)
  end
            
  @doc """
  Adds the ice-cream icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ice-cream

  ```
  graph
  |> fontawesome_ice_cream({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ice_cream(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ice_cream(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ice_cream(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 342}, {50, 57}, opts)
  end
            
  @doc """
  Adds the icicles icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/icicles

  ```
  graph
  |> fontawesome_icicles({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_icicles(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_icicles(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_icicles(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the icons icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/icons

  ```
  graph
  |> fontawesome_icons({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_icons(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_icons(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_icons(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the id-badge icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/id-badge

  ```
  graph
  |> fontawesome_id_badge({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_id_badge(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_id_badge(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_id_badge(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 335}, {50, 67}, opts)
  end
            
  @doc """
  Adds the id-card-clip icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/id-card-clip

  ```
  graph
  |> fontawesome_id_card_clip({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_id_card_clip(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_id_card_clip(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_id_card_clip(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 308}, {50, 44}, opts)
  end
            
  @doc """
  Adds the id-card icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/id-card

  ```
  graph
  |> fontawesome_id_card({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_id_card(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_id_card(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_id_card(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 352}, {50, 44}, opts)
  end
            
  @doc """
  Adds the igloo icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/igloo

  ```
  graph
  |> fontawesome_igloo({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_igloo(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_igloo(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_igloo(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 396}, {50, 44}, opts)
  end
            
  @doc """
  Adds the image-portrait icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/image-portrait

  ```
  graph
  |> fontawesome_image_portrait({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_image_portrait(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_image_portrait(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_image_portrait(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 402}, {50, 67}, opts)
  end
            
  @doc """
  Adds the image icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/image

  ```
  graph
  |> fontawesome_image({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_image(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_image(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_image(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the images icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/images

  ```
  graph
  |> fontawesome_images({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_images(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_images(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_images(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 440}, {50, 44}, opts)
  end
            
  @doc """
  Adds the inbox icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/inbox

  ```
  graph
  |> fontawesome_inbox({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_inbox(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_inbox(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_inbox(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the indent icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/indent

  ```
  graph
  |> fontawesome_indent({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_indent(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_indent(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_indent(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 399}, {50, 57}, opts)
  end
            
  @doc """
  Adds the indian-rupee-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/indian-rupee-sign

  ```
  graph
  |> fontawesome_indian_rupee_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_indian_rupee_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_indian_rupee_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_indian_rupee_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 80}, {50, 80}, opts)
  end
            
  @doc """
  Adds the industry icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/industry

  ```
  graph
  |> fontawesome_industry({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_industry(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_industry(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_industry(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 484}, {50, 44}, opts)
  end
            
  @doc """
  Adds the infinity icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/infinity

  ```
  graph
  |> fontawesome_infinity({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_infinity(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_infinity(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_infinity(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1440}, {50, 40}, opts)
  end
            
  @doc """
  Adds the info icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/info

  ```
  graph
  |> fontawesome_info({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_info(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_info(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_info(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 0}, {50, 133}, opts)
  end
            
  @doc """
  Adds the italic icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/italic

  ```
  graph
  |> fontawesome_italic({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_italic(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_italic(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_italic(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 469}, {50, 67}, opts)
  end
            
  @doc """
  Adds the j icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/j

  ```
  graph
  |> fontawesome_j({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_j(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_j(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_j(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 160}, {50, 80}, opts)
  end
            
  @doc """
  Adds the jar-wheat icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/jar-wheat

  ```
  graph
  |> fontawesome_jar_wheat({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_jar_wheat(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_jar_wheat(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_jar_wheat(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 240}, {50, 80}, opts)
  end
            
  @doc """
  Adds the jar icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/jar

  ```
  graph
  |> fontawesome_jar({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_jar(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_jar(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_jar(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 320}, {50, 80}, opts)
  end
            
  @doc """
  Adds the jedi icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/jedi

  ```
  graph
  |> fontawesome_jedi({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_jedi(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_jedi(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_jedi(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 528}, {50, 44}, opts)
  end
            
  @doc """
  Adds the jet-fighter-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/jet-fighter-up

  ```
  graph
  |> fontawesome_jet_fighter_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_jet_fighter_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_jet_fighter_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_jet_fighter_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the jet-fighter icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/jet-fighter

  ```
  graph
  |> fontawesome_jet_fighter({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_jet_fighter(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_jet_fighter(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_jet_fighter(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1480}, {50, 40}, opts)
  end
            
  @doc """
  Adds the joint icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/joint

  ```
  graph
  |> fontawesome_joint({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_joint(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_joint(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_joint(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1520}, {50, 40}, opts)
  end
            
  @doc """
  Adds the jug-detergent icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/jug-detergent

  ```
  graph
  |> fontawesome_jug_detergent({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_jug_detergent(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_jug_detergent(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_jug_detergent(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 536}, {50, 67}, opts)
  end
            
  @doc """
  Adds the k icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/k

  ```
  graph
  |> fontawesome_k({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_k(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_k(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_k(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 460}, {50, 80}, opts)
  end
            
  @doc """
  Adds the kaaba icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/kaaba

  ```
  graph
  |> fontawesome_kaaba({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_kaaba(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_kaaba(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_kaaba(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 572}, {50, 44}, opts)
  end
            
  @doc """
  Adds the key icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/key

  ```
  graph
  |> fontawesome_key({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_key(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_key(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_key(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the keyboard icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/keyboard

  ```
  graph
  |> fontawesome_keyboard({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_keyboard(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_keyboard(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_keyboard(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 616}, {50, 44}, opts)
  end
            
  @doc """
  Adds the khanda icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/khanda

  ```
  graph
  |> fontawesome_khanda({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_khanda(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_khanda(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_khanda(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the kip-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/kip-sign

  ```
  graph
  |> fontawesome_kip_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_kip_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_kip_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_kip_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 603}, {50, 67}, opts)
  end
            
  @doc """
  Adds the kit-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/kit-medical

  ```
  graph
  |> fontawesome_kit_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_kit_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_kit_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_kit_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 660}, {50, 44}, opts)
  end
            
  @doc """
  Adds the kitchen-set icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/kitchen-set

  ```
  graph
  |> fontawesome_kitchen_set({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_kitchen_set(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_kitchen_set(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_kitchen_set(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 704}, {50, 44}, opts)
  end
            
  @doc """
  Adds the kiwi-bird icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/kiwi-bird

  ```
  graph
  |> fontawesome_kiwi_bird({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_kiwi_bird(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_kiwi_bird(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_kiwi_bird(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 748}, {50, 44}, opts)
  end
            
  @doc """
  Adds the l icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/l

  ```
  graph
  |> fontawesome_l({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_l(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_l(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_l(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 460}, {50, 80}, opts)
  end
            
  @doc """
  Adds the land-mine-on icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/land-mine-on

  ```
  graph
  |> fontawesome_land_mine_on({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_land_mine_on(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_land_mine_on(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_land_mine_on(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1560}, {50, 40}, opts)
  end
            
  @doc """
  Adds the landmark-dome icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/landmark-dome

  ```
  graph
  |> fontawesome_landmark_dome({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_landmark_dome(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_landmark_dome(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_landmark_dome(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the landmark-flag icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/landmark-flag

  ```
  graph
  |> fontawesome_landmark_flag({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_landmark_flag(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_landmark_flag(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_landmark_flag(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the landmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/landmark

  ```
  graph
  |> fontawesome_landmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_landmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_landmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_landmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the language icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/language

  ```
  graph
  |> fontawesome_language({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_language(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_language(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_language(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1600}, {50, 40}, opts)
  end
            
  @doc """
  Adds the laptop-code icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/laptop-code

  ```
  graph
  |> fontawesome_laptop_code({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_laptop_code(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_laptop_code(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_laptop_code(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1640}, {50, 40}, opts)
  end
            
  @doc """
  Adds the laptop-file icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/laptop-file

  ```
  graph
  |> fontawesome_laptop_file({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_laptop_file(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_laptop_file(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_laptop_file(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1680}, {50, 40}, opts)
  end
            
  @doc """
  Adds the laptop-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/laptop-medical

  ```
  graph
  |> fontawesome_laptop_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_laptop_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_laptop_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_laptop_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1720}, {50, 40}, opts)
  end
            
  @doc """
  Adds the laptop icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/laptop

  ```
  graph
  |> fontawesome_laptop({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_laptop(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_laptop(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_laptop(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the lari-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/lari-sign

  ```
  graph
  |> fontawesome_lari_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_lari_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_lari_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_lari_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 670}, {50, 67}, opts)
  end
            
  @doc """
  Adds the layer-group icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/layer-group

  ```
  graph
  |> fontawesome_layer_group({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_layer_group(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_layer_group(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_layer_group(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 792}, {50, 44}, opts)
  end
            
  @doc """
  Adds the leaf icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/leaf

  ```
  graph
  |> fontawesome_leaf({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_leaf(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_leaf(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_leaf(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the left-long icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/left-long

  ```
  graph
  |> fontawesome_left_long({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_left_long(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_left_long(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_left_long(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the left-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/left-right

  ```
  graph
  |> fontawesome_left_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_left_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_left_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_left_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the lemon icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/lemon

  ```
  graph
  |> fontawesome_lemon({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_lemon(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_lemon(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_lemon(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 456}, {50, 57}, opts)
  end
            
  @doc """
  Adds the less-than-equal icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/less-than-equal

  ```
  graph
  |> fontawesome_less_than_equal({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_less_than_equal(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_less_than_equal(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_less_than_equal(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 513}, {50, 57}, opts)
  end
            
  @doc """
  Adds the less-than icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/less-than

  ```
  graph
  |> fontawesome_less_than({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_less_than(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_less_than(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_less_than(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the life-ring icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/life-ring

  ```
  graph
  |> fontawesome_life_ring({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_life_ring(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_life_ring(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_life_ring(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the lightbulb icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/lightbulb

  ```
  graph
  |> fontawesome_lightbulb({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_lightbulb(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_lightbulb(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_lightbulb(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the lines-leaning icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/lines-leaning

  ```
  graph
  |> fontawesome_lines_leaning({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_lines_leaning(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_lines_leaning(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_lines_leaning(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the link-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/link-slash

  ```
  graph
  |> fontawesome_link_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_link_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_link_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_link_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the link icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/link

  ```
  graph
  |> fontawesome_link({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_link(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_link(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_link(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the lira-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/lira-sign

  ```
  graph
  |> fontawesome_lira_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_lira_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_lira_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_lira_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 460}, {50, 80}, opts)
  end
            
  @doc """
  Adds the list-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/list-check

  ```
  graph
  |> fontawesome_list_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_list_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_list_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_list_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1373}, {50, 50}, opts)
  end
            
  @doc """
  Adds the list-ol icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/list-ol

  ```
  graph
  |> fontawesome_list_ol({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_list_ol(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_list_ol(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_list_ol(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 0}, {50, 50}, opts)
  end
            
  @doc """
  Adds the list-ul icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/list-ul

  ```
  graph
  |> fontawesome_list_ul({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_list_ul(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_list_ul(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_list_ul(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 50}, {50, 50}, opts)
  end
            
  @doc """
  Adds the list icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/list

  ```
  graph
  |> fontawesome_list({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_list(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_list(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_list(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the litecoin-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/litecoin-sign

  ```
  graph
  |> fontawesome_litecoin_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_litecoin_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_litecoin_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_litecoin_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the location-arrow icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/location-arrow

  ```
  graph
  |> fontawesome_location_arrow({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_location_arrow(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_location_arrow(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_location_arrow(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 570}, {50, 57}, opts)
  end
            
  @doc """
  Adds the location-crosshairs icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/location-crosshairs

  ```
  graph
  |> fontawesome_location_crosshairs({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_location_crosshairs(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_location_crosshairs(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_location_crosshairs(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the location-dot icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/location-dot

  ```
  graph
  |> fontawesome_location_dot({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_location_dot(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_location_dot(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_location_dot(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the location-pin-lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/location-pin-lock

  ```
  graph
  |> fontawesome_location_pin_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_location_pin_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_location_pin_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_location_pin_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the location-pin icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/location-pin

  ```
  graph
  |> fontawesome_location_pin({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_location_pin(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_location_pin(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_location_pin(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the lock-open icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/lock-open

  ```
  graph
  |> fontawesome_lock_open({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_lock_open(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_lock_open(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_lock_open(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 836}, {50, 44}, opts)
  end
            
  @doc """
  Adds the lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/lock

  ```
  graph
  |> fontawesome_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 627}, {50, 57}, opts)
  end
            
  @doc """
  Adds the locust icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/locust

  ```
  graph
  |> fontawesome_locust({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_locust(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_locust(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_locust(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 880}, {50, 44}, opts)
  end
            
  @doc """
  Adds the lungs-virus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/lungs-virus

  ```
  graph
  |> fontawesome_lungs_virus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_lungs_virus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_lungs_virus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_lungs_virus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the lungs icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/lungs

  ```
  graph
  |> fontawesome_lungs({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_lungs(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_lungs(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_lungs(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the m icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/m

  ```
  graph
  |> fontawesome_m({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_m(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_m(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_m(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 684}, {50, 57}, opts)
  end
            
  @doc """
  Adds the magnet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/magnet

  ```
  graph
  |> fontawesome_magnet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_magnet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_magnet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_magnet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 741}, {50, 57}, opts)
  end
            
  @doc """
  Adds the magnifying-glass-arrow-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/magnifying-glass-arrow-right

  ```
  graph
  |> fontawesome_magnifying_glass_arrow_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_magnifying_glass_arrow_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_magnifying_glass_arrow_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_magnifying_glass_arrow_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the magnifying-glass-chart icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/magnifying-glass-chart

  ```
  graph
  |> fontawesome_magnifying_glass_chart({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_magnifying_glass_chart(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_magnifying_glass_chart(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_magnifying_glass_chart(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 300}, {50, 50}, opts)
  end
            
  @doc """
  Adds the magnifying-glass-dollar icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/magnifying-glass-dollar

  ```
  graph
  |> fontawesome_magnifying_glass_dollar({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_magnifying_glass_dollar(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_magnifying_glass_dollar(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_magnifying_glass_dollar(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 350}, {50, 50}, opts)
  end
            
  @doc """
  Adds the magnifying-glass-location icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/magnifying-glass-location

  ```
  graph
  |> fontawesome_magnifying_glass_location({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_magnifying_glass_location(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_magnifying_glass_location(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_magnifying_glass_location(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 400}, {50, 50}, opts)
  end
            
  @doc """
  Adds the magnifying-glass-minus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/magnifying-glass-minus

  ```
  graph
  |> fontawesome_magnifying_glass_minus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_magnifying_glass_minus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_magnifying_glass_minus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_magnifying_glass_minus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 450}, {50, 50}, opts)
  end
            
  @doc """
  Adds the magnifying-glass-plus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/magnifying-glass-plus

  ```
  graph
  |> fontawesome_magnifying_glass_plus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_magnifying_glass_plus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_magnifying_glass_plus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_magnifying_glass_plus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 500}, {50, 50}, opts)
  end
            
  @doc """
  Adds the magnifying-glass icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/magnifying-glass

  ```
  graph
  |> fontawesome_magnifying_glass({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_magnifying_glass(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_magnifying_glass(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_magnifying_glass(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 550}, {50, 50}, opts)
  end
            
  @doc """
  Adds the manat-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/manat-sign

  ```
  graph
  |> fontawesome_manat_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_manat_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_manat_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_manat_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the map-location-dot icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/map-location-dot

  ```
  graph
  |> fontawesome_map_location_dot({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_map_location_dot(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_map_location_dot(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_map_location_dot(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 924}, {50, 44}, opts)
  end
            
  @doc """
  Adds the map-location icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/map-location

  ```
  graph
  |> fontawesome_map_location({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_map_location(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_map_location(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_map_location(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 968}, {50, 44}, opts)
  end
            
  @doc """
  Adds the map-pin icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/map-pin

  ```
  graph
  |> fontawesome_map_pin({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_map_pin(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_map_pin(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_map_pin(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 460}, {50, 80}, opts)
  end
            
  @doc """
  Adds the map icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/map

  ```
  graph
  |> fontawesome_map({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_map(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_map(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_map(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1012}, {50, 44}, opts)
  end
            
  @doc """
  Adds the marker icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/marker

  ```
  graph
  |> fontawesome_marker({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_marker(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_marker(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_marker(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 600}, {50, 50}, opts)
  end
            
  @doc """
  Adds the mars-and-venus-burst icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mars-and-venus-burst

  ```
  graph
  |> fontawesome_mars_and_venus_burst({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mars_and_venus_burst(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mars_and_venus_burst(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mars_and_venus_burst(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the mars-and-venus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mars-and-venus

  ```
  graph
  |> fontawesome_mars_and_venus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mars_and_venus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mars_and_venus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mars_and_venus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 650}, {50, 50}, opts)
  end
            
  @doc """
  Adds the mars-double icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mars-double

  ```
  graph
  |> fontawesome_mars_double({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mars_double(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mars_double(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mars_double(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the mars-stroke-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mars-stroke-right

  ```
  graph
  |> fontawesome_mars_stroke_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mars_stroke_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mars_stroke_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mars_stroke_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the mars-stroke-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mars-stroke-up

  ```
  graph
  |> fontawesome_mars_stroke_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mars_stroke_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mars_stroke_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mars_stroke_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 460}, {50, 80}, opts)
  end
            
  @doc """
  Adds the mars-stroke icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mars-stroke

  ```
  graph
  |> fontawesome_mars_stroke({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mars_stroke(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mars_stroke(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mars_stroke(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 700}, {50, 50}, opts)
  end
            
  @doc """
  Adds the mars icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mars

  ```
  graph
  |> fontawesome_mars({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mars(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mars(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mars(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 798}, {50, 57}, opts)
  end
            
  @doc """
  Adds the martini-glass-citrus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/martini-glass-citrus

  ```
  graph
  |> fontawesome_martini_glass_citrus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_martini_glass_citrus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_martini_glass_citrus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_martini_glass_citrus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1056}, {50, 44}, opts)
  end
            
  @doc """
  Adds the martini-glass-empty icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/martini-glass-empty

  ```
  graph
  |> fontawesome_martini_glass_empty({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_martini_glass_empty(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_martini_glass_empty(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_martini_glass_empty(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 750}, {50, 50}, opts)
  end
            
  @doc """
  Adds the martini-glass icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/martini-glass

  ```
  graph
  |> fontawesome_martini_glass({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_martini_glass(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_martini_glass(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_martini_glass(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 800}, {50, 50}, opts)
  end
            
  @doc """
  Adds the mask-face icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mask-face

  ```
  graph
  |> fontawesome_mask_face({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mask_face(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mask_face(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mask_face(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the mask-ventilator icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mask-ventilator

  ```
  graph
  |> fontawesome_mask_ventilator({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mask_ventilator(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mask_ventilator(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mask_ventilator(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the mask icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mask

  ```
  graph
  |> fontawesome_mask({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mask(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mask(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mask(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1100}, {50, 44}, opts)
  end
            
  @doc """
  Adds the masks-theater icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/masks-theater

  ```
  graph
  |> fontawesome_masks_theater({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_masks_theater(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_masks_theater(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_masks_theater(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the mattress-pillow icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mattress-pillow

  ```
  graph
  |> fontawesome_mattress_pillow({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mattress_pillow(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mattress_pillow(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mattress_pillow(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the maximize icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/maximize

  ```
  graph
  |> fontawesome_maximize({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_maximize(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_maximize(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_maximize(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 850}, {50, 50}, opts)
  end
            
  @doc """
  Adds the medal icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/medal

  ```
  graph
  |> fontawesome_medal({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_medal(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_medal(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_medal(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 900}, {50, 50}, opts)
  end
            
  @doc """
  Adds the memory icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/memory

  ```
  graph
  |> fontawesome_memory({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_memory(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_memory(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_memory(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1144}, {50, 44}, opts)
  end
            
  @doc """
  Adds the menorah icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/menorah

  ```
  graph
  |> fontawesome_menorah({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_menorah(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_menorah(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_menorah(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the mercury icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mercury

  ```
  graph
  |> fontawesome_mercury({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mercury(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mercury(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mercury(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the message icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/message

  ```
  graph
  |> fontawesome_message({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_message(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_message(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_message(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 950}, {50, 50}, opts)
  end
            
  @doc """
  Adds the meteor icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/meteor

  ```
  graph
  |> fontawesome_meteor({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_meteor(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_meteor(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_meteor(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1000}, {50, 50}, opts)
  end
            
  @doc """
  Adds the microchip icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/microchip

  ```
  graph
  |> fontawesome_microchip({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_microchip(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_microchip(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_microchip(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1050}, {50, 50}, opts)
  end
            
  @doc """
  Adds the microphone-lines-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/microphone-lines-slash

  ```
  graph
  |> fontawesome_microphone_lines_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_microphone_lines_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_microphone_lines_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_microphone_lines_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the microphone-lines icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/microphone-lines

  ```
  graph
  |> fontawesome_microphone_lines({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_microphone_lines(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_microphone_lines(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_microphone_lines(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the microphone-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/microphone-slash

  ```
  graph
  |> fontawesome_microphone_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_microphone_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_microphone_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_microphone_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the microphone icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/microphone

  ```
  graph
  |> fontawesome_microphone({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_microphone(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_microphone(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_microphone(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the microscope icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/microscope

  ```
  graph
  |> fontawesome_microscope({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_microscope(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_microscope(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_microscope(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the mill-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mill-sign

  ```
  graph
  |> fontawesome_mill_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mill_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mill_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mill_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the minimize icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/minimize

  ```
  graph
  |> fontawesome_minimize({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_minimize(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_minimize(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_minimize(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the minus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/minus

  ```
  graph
  |> fontawesome_minus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_minus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_minus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_minus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 855}, {50, 57}, opts)
  end
            
  @doc """
  Adds the mitten icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mitten

  ```
  graph
  |> fontawesome_mitten({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mitten(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mitten(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mitten(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 912}, {50, 57}, opts)
  end
            
  @doc """
  Adds the mobile-button icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mobile-button

  ```
  graph
  |> fontawesome_mobile_button({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mobile_button(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mobile_button(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mobile_button(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the mobile-retro icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mobile-retro

  ```
  graph
  |> fontawesome_mobile_retro({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mobile_retro(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mobile_retro(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mobile_retro(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 460}, {50, 80}, opts)
  end
            
  @doc """
  Adds the mobile-screen-button icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mobile-screen-button

  ```
  graph
  |> fontawesome_mobile_screen_button({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mobile_screen_button(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mobile_screen_button(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mobile_screen_button(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the mobile-screen icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mobile-screen

  ```
  graph
  |> fontawesome_mobile_screen({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mobile_screen(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mobile_screen(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mobile_screen(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the mobile icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mobile

  ```
  graph
  |> fontawesome_mobile({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mobile(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mobile(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mobile(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the money-bill-1-wave icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/money-bill-1-wave

  ```
  graph
  |> fontawesome_money_bill_1_wave({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_money_bill_1_wave(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_money_bill_1_wave(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_money_bill_1_wave(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1188}, {50, 44}, opts)
  end
            
  @doc """
  Adds the money-bill-1 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/money-bill-1

  ```
  graph
  |> fontawesome_money_bill_1({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_money_bill_1(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_money_bill_1(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_money_bill_1(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1232}, {50, 44}, opts)
  end
            
  @doc """
  Adds the money-bill-transfer icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/money-bill-transfer

  ```
  graph
  |> fontawesome_money_bill_transfer({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_money_bill_transfer(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_money_bill_transfer(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_money_bill_transfer(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the money-bill-trend-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/money-bill-trend-up

  ```
  graph
  |> fontawesome_money_bill_trend_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_money_bill_trend_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_money_bill_trend_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_money_bill_trend_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the money-bill-wave icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/money-bill-wave

  ```
  graph
  |> fontawesome_money_bill_wave({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_money_bill_wave(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_money_bill_wave(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_money_bill_wave(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1276}, {50, 44}, opts)
  end
            
  @doc """
  Adds the money-bill-wheat icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/money-bill-wheat

  ```
  graph
  |> fontawesome_money_bill_wheat({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_money_bill_wheat(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_money_bill_wheat(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_money_bill_wheat(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the money-bill icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/money-bill

  ```
  graph
  |> fontawesome_money_bill({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_money_bill(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_money_bill(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_money_bill(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1320}, {50, 44}, opts)
  end
            
  @doc """
  Adds the money-bills icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/money-bills

  ```
  graph
  |> fontawesome_money_bills({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_money_bills(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_money_bills(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_money_bills(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the money-check-dollar icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/money-check-dollar

  ```
  graph
  |> fontawesome_money_check_dollar({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_money_check_dollar(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_money_check_dollar(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_money_check_dollar(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1364}, {50, 44}, opts)
  end
            
  @doc """
  Adds the money-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/money-check

  ```
  graph
  |> fontawesome_money_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_money_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_money_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_money_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1408}, {50, 44}, opts)
  end
            
  @doc """
  Adds the monument icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/monument

  ```
  graph
  |> fontawesome_monument({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_monument(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_monument(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_monument(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the moon icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/moon

  ```
  graph
  |> fontawesome_moon({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_moon(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_moon(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_moon(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 754}, {50, 67}, opts)
  end
            
  @doc """
  Adds the mortar-pestle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mortar-pestle

  ```
  graph
  |> fontawesome_mortar_pestle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mortar_pestle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mortar_pestle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mortar_pestle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1300}, {50, 50}, opts)
  end
            
  @doc """
  Adds the mosque icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mosque

  ```
  graph
  |> fontawesome_mosque({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mosque(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mosque(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mosque(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the mosquito-net icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mosquito-net

  ```
  graph
  |> fontawesome_mosquito_net({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mosquito_net(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mosquito_net(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mosquito_net(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the mosquito icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mosquito

  ```
  graph
  |> fontawesome_mosquito({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mosquito(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mosquito(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mosquito(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the motorcycle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/motorcycle

  ```
  graph
  |> fontawesome_motorcycle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_motorcycle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_motorcycle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_motorcycle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the mound icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mound

  ```
  graph
  |> fontawesome_mound({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mound(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mound(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mound(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1452}, {50, 44}, opts)
  end
            
  @doc """
  Adds the mountain-city icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mountain-city

  ```
  graph
  |> fontawesome_mountain_city({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mountain_city(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mountain_city(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mountain_city(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the mountain-sun icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mountain-sun

  ```
  graph
  |> fontawesome_mountain_sun({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mountain_sun(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mountain_sun(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mountain_sun(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the mountain icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mountain

  ```
  graph
  |> fontawesome_mountain({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mountain(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mountain(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mountain(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1350}, {50, 50}, opts)
  end
            
  @doc """
  Adds the mug-hot icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mug-hot

  ```
  graph
  |> fontawesome_mug_hot({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mug_hot(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mug_hot(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mug_hot(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the mug-saucer icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/mug-saucer

  ```
  graph
  |> fontawesome_mug_saucer({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_mug_saucer(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_mug_saucer(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_mug_saucer(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the music icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/music

  ```
  graph
  |> fontawesome_music({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_music(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_music(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_music(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the n icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/n

  ```
  graph
  |> fontawesome_n({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_n(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_n(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_n(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 0}, {50, 67}, opts)
  end
            
  @doc """
  Adds the naira-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/naira-sign

  ```
  graph
  |> fontawesome_naira_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_naira_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_naira_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_naira_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the network-wired icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/network-wired

  ```
  graph
  |> fontawesome_network_wired({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_network_wired(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_network_wired(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_network_wired(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the neuter icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/neuter

  ```
  graph
  |> fontawesome_neuter({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_neuter(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_neuter(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_neuter(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 67}, {50, 67}, opts)
  end
            
  @doc """
  Adds the newspaper icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/newspaper

  ```
  graph
  |> fontawesome_newspaper({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_newspaper(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_newspaper(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_newspaper(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the not-equal icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/not-equal

  ```
  graph
  |> fontawesome_not_equal({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_not_equal(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_not_equal(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_not_equal(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the notdef icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/notdef

  ```
  graph
  |> fontawesome_notdef({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_notdef(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_notdef(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_notdef(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 134}, {50, 67}, opts)
  end
            
  @doc """
  Adds the note-sticky icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/note-sticky

  ```
  graph
  |> fontawesome_note_sticky({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_note_sticky(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_note_sticky(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_note_sticky(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the notes-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/notes-medical

  ```
  graph
  |> fontawesome_notes_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_notes_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_notes_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_notes_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the o icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/o

  ```
  graph
  |> fontawesome_o({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_o(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_o(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_o(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the object-group icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/object-group

  ```
  graph
  |> fontawesome_object_group({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_object_group(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_object_group(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_object_group(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1496}, {50, 44}, opts)
  end
            
  @doc """
  Adds the object-ungroup icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/object-ungroup

  ```
  graph
  |> fontawesome_object_ungroup({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_object_ungroup(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_object_ungroup(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_object_ungroup(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the oil-can icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/oil-can

  ```
  graph
  |> fontawesome_oil_can({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_oil_can(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_oil_can(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_oil_can(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the oil-well icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/oil-well

  ```
  graph
  |> fontawesome_oil_well({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_oil_well(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_oil_well(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_oil_well(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1540}, {50, 44}, opts)
  end
            
  @doc """
  Adds the om icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/om

  ```
  graph
  |> fontawesome_om({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_om(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_om(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_om(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the otter icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/otter

  ```
  graph
  |> fontawesome_otter({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_otter(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_otter(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_otter(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the outdent icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/outdent

  ```
  graph
  |> fontawesome_outdent({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_outdent(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_outdent(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_outdent(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the p icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/p

  ```
  graph
  |> fontawesome_p({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_p(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_p(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_p(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 460}, {50, 80}, opts)
  end
            
  @doc """
  Adds the pager icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pager

  ```
  graph
  |> fontawesome_pager({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pager(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pager(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pager(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the paint-roller icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/paint-roller

  ```
  graph
  |> fontawesome_paint_roller({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_paint_roller(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_paint_roller(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_paint_roller(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the paintbrush icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/paintbrush

  ```
  graph
  |> fontawesome_paintbrush({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_paintbrush(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_paintbrush(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_paintbrush(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1584}, {50, 44}, opts)
  end
            
  @doc """
  Adds the palette icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/palette

  ```
  graph
  |> fontawesome_palette({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_palette(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_palette(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_palette(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the pallet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pallet

  ```
  graph
  |> fontawesome_pallet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pallet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pallet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pallet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the panorama icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/panorama

  ```
  graph
  |> fontawesome_panorama({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_panorama(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_panorama(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_panorama(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the paper-plane icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/paper-plane

  ```
  graph
  |> fontawesome_paper_plane({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_paper_plane(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_paper_plane(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_paper_plane(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the paperclip icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/paperclip

  ```
  graph
  |> fontawesome_paperclip({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_paperclip(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_paperclip(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_paperclip(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the parachute-box icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/parachute-box

  ```
  graph
  |> fontawesome_parachute_box({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_parachute_box(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_parachute_box(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_parachute_box(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the paragraph icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/paragraph

  ```
  graph
  |> fontawesome_paragraph({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_paragraph(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_paragraph(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_paragraph(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the passport icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/passport

  ```
  graph
  |> fontawesome_passport({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_passport(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_passport(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_passport(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the paste icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/paste

  ```
  graph
  |> fontawesome_paste({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_paste(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_paste(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_paste(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the pause icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pause

  ```
  graph
  |> fontawesome_pause({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pause(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pause(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pause(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 460}, {50, 80}, opts)
  end
            
  @doc """
  Adds the paw icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/paw

  ```
  graph
  |> fontawesome_paw({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_paw(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_paw(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_paw(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the peace icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/peace

  ```
  graph
  |> fontawesome_peace({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_peace(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_peace(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_peace(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the pen-clip icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pen-clip

  ```
  graph
  |> fontawesome_pen_clip({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pen_clip(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pen_clip(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pen_clip(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the pen-fancy icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pen-fancy

  ```
  graph
  |> fontawesome_pen_fancy({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pen_fancy(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pen_fancy(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pen_fancy(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the pen-nib icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pen-nib

  ```
  graph
  |> fontawesome_pen_nib({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pen_nib(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pen_nib(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pen_nib(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the pen-ruler icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pen-ruler

  ```
  graph
  |> fontawesome_pen_ruler({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pen_ruler(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pen_ruler(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pen_ruler(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the pen-to-square icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pen-to-square

  ```
  graph
  |> fontawesome_pen_to_square({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pen_to_square(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pen_to_square(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pen_to_square(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the pen icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pen

  ```
  graph
  |> fontawesome_pen({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pen(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pen(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pen(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the pencil icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pencil

  ```
  graph
  |> fontawesome_pencil({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pencil(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pencil(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pencil(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the people-arrows icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/people-arrows

  ```
  graph
  |> fontawesome_people_arrows({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_people_arrows(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_people_arrows(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_people_arrows(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the people-carry-box icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/people-carry-box

  ```
  graph
  |> fontawesome_people_carry_box({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_people_carry_box(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_people_carry_box(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_people_carry_box(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the people-group icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/people-group

  ```
  graph
  |> fontawesome_people_group({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_people_group(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_people_group(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_people_group(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the people-line icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/people-line

  ```
  graph
  |> fontawesome_people_line({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_people_line(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_people_line(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_people_line(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the people-pulling icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/people-pulling

  ```
  graph
  |> fontawesome_people_pulling({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_people_pulling(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_people_pulling(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_people_pulling(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the people-robbery icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/people-robbery

  ```
  graph
  |> fontawesome_people_robbery({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_people_robbery(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_people_robbery(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_people_robbery(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the people-roof icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/people-roof

  ```
  graph
  |> fontawesome_people_roof({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_people_roof(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_people_roof(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_people_roof(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the pepper-hot icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pepper-hot

  ```
  graph
  |> fontawesome_pepper_hot({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pepper_hot(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pepper_hot(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pepper_hot(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the percent icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/percent

  ```
  graph
  |> fontawesome_percent({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_percent(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_percent(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_percent(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 201}, {50, 67}, opts)
  end
            
  @doc """
  Adds the person-arrow-down-to-line icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-arrow-down-to-line

  ```
  graph
  |> fontawesome_person_arrow_down_to_line({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_arrow_down_to_line(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_arrow_down_to_line(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_arrow_down_to_line(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the person-arrow-up-from-line icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-arrow-up-from-line

  ```
  graph
  |> fontawesome_person_arrow_up_from_line({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_arrow_up_from_line(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_arrow_up_from_line(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_arrow_up_from_line(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1789}, {50, 40}, opts)
  end
            
  @doc """
  Adds the person-biking icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-biking

  ```
  graph
  |> fontawesome_person_biking({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_biking(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_biking(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_biking(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 0}, {50, 40}, opts)
  end
            
  @doc """
  Adds the person-booth icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-booth

  ```
  graph
  |> fontawesome_person_booth({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_booth(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_booth(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_booth(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-breastfeeding icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-breastfeeding

  ```
  graph
  |> fontawesome_person_breastfeeding({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_breastfeeding(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_breastfeeding(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_breastfeeding(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the person-burst icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-burst

  ```
  graph
  |> fontawesome_person_burst({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_burst(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_burst(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_burst(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 40}, {50, 40}, opts)
  end
            
  @doc """
  Adds the person-cane icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-cane

  ```
  graph
  |> fontawesome_person_cane({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_cane(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_cane(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_cane(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the person-chalkboard icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-chalkboard

  ```
  graph
  |> fontawesome_person_chalkboard({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_chalkboard(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_chalkboard(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_chalkboard(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 80}, {50, 40}, opts)
  end
            
  @doc """
  Adds the person-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-circle-check

  ```
  graph
  |> fontawesome_person_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-circle-exclamation

  ```
  graph
  |> fontawesome_person_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-circle-minus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-circle-minus

  ```
  graph
  |> fontawesome_person_circle_minus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_circle_minus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_circle_minus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_circle_minus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-circle-plus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-circle-plus

  ```
  graph
  |> fontawesome_person_circle_plus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_circle_plus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_circle_plus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_circle_plus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-circle-question icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-circle-question

  ```
  graph
  |> fontawesome_person_circle_question({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_circle_question(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_circle_question(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_circle_question(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-circle-xmark

  ```
  graph
  |> fontawesome_person_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-digging icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-digging

  ```
  graph
  |> fontawesome_person_digging({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_digging(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_digging(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_digging(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-dots-from-line icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-dots-from-line

  ```
  graph
  |> fontawesome_person_dots_from_line({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_dots_from_line(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_dots_from_line(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_dots_from_line(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-dress-burst icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-dress-burst

  ```
  graph
  |> fontawesome_person_dress_burst({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_dress_burst(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_dress_burst(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_dress_burst(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 120}, {50, 40}, opts)
  end
            
  @doc """
  Adds the person-dress icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-dress

  ```
  graph
  |> fontawesome_person_dress({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_dress(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_dress(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_dress(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 460}, {50, 80}, opts)
  end
            
  @doc """
  Adds the person-drowning icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-drowning

  ```
  graph
  |> fontawesome_person_drowning({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_drowning(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_drowning(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_drowning(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-falling-burst icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-falling-burst

  ```
  graph
  |> fontawesome_person_falling_burst({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_falling_burst(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_falling_burst(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_falling_burst(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 160}, {50, 40}, opts)
  end
            
  @doc """
  Adds the person-falling icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-falling

  ```
  graph
  |> fontawesome_person_falling({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_falling(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_falling(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_falling(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the person-half-dress icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-half-dress

  ```
  graph
  |> fontawesome_person_half_dress({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_half_dress(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_half_dress(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_half_dress(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 460}, {50, 80}, opts)
  end
            
  @doc """
  Adds the person-harassing icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-harassing

  ```
  graph
  |> fontawesome_person_harassing({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_harassing(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_harassing(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_harassing(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-hiking icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-hiking

  ```
  graph
  |> fontawesome_person_hiking({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_hiking(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_hiking(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_hiking(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 268}, {50, 67}, opts)
  end
            
  @doc """
  Adds the person-military-pointing icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-military-pointing

  ```
  graph
  |> fontawesome_person_military_pointing({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_military_pointing(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_military_pointing(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_military_pointing(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-military-rifle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-military-rifle

  ```
  graph
  |> fontawesome_person_military_rifle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_military_rifle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_military_rifle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_military_rifle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the person-military-to-person icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-military-to-person

  ```
  graph
  |> fontawesome_person_military_to_person({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_military_to_person(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_military_to_person(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_military_to_person(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the person-praying icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-praying

  ```
  graph
  |> fontawesome_person_praying({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_praying(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_praying(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_praying(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the person-pregnant icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-pregnant

  ```
  graph
  |> fontawesome_person_pregnant({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_pregnant(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_pregnant(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_pregnant(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 335}, {50, 67}, opts)
  end
            
  @doc """
  Adds the person-rays icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-rays

  ```
  graph
  |> fontawesome_person_rays({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_rays(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_rays(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_rays(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the person-rifle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-rifle

  ```
  graph
  |> fontawesome_person_rifle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_rifle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_rifle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_rifle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-running icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-running

  ```
  graph
  |> fontawesome_person_running({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_running(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_running(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_running(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the person-shelter icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-shelter

  ```
  graph
  |> fontawesome_person_shelter({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_shelter(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_shelter(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_shelter(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the person-skating icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-skating

  ```
  graph
  |> fontawesome_person_skating({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_skating(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_skating(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_skating(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the person-skiing-nordic icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-skiing-nordic

  ```
  graph
  |> fontawesome_person_skiing_nordic({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_skiing_nordic(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_skiing_nordic(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_skiing_nordic(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-skiing icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-skiing

  ```
  graph
  |> fontawesome_person_skiing({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_skiing(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_skiing(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_skiing(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the person-snowboarding icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-snowboarding

  ```
  graph
  |> fontawesome_person_snowboarding({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_snowboarding(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_snowboarding(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_snowboarding(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the person-swimming icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-swimming

  ```
  graph
  |> fontawesome_person_swimming({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_swimming(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_swimming(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_swimming(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-through-window icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-through-window

  ```
  graph
  |> fontawesome_person_through_window({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_through_window(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_through_window(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_through_window(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 200}, {50, 40}, opts)
  end
            
  @doc """
  Adds the person-walking-arrow-loop-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-walking-arrow-loop-left

  ```
  graph
  |> fontawesome_person_walking_arrow_loop_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_walking_arrow_loop_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_walking_arrow_loop_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_walking_arrow_loop_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 240}, {50, 40}, opts)
  end
            
  @doc """
  Adds the person-walking-arrow-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-walking-arrow-right

  ```
  graph
  |> fontawesome_person_walking_arrow_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_walking_arrow_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_walking_arrow_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_walking_arrow_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 280}, {50, 40}, opts)
  end
            
  @doc """
  Adds the person-walking-dashed-line-arrow-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-walking-dashed-line-arrow-right

  ```
  graph
  |> fontawesome_person_walking_dashed_line_arrow_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_walking_dashed_line_arrow_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_walking_dashed_line_arrow_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_walking_dashed_line_arrow_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 320}, {50, 40}, opts)
  end
            
  @doc """
  Adds the person-walking-luggage icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-walking-luggage

  ```
  graph
  |> fontawesome_person_walking_luggage({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_walking_luggage(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_walking_luggage(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_walking_luggage(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the person-walking-with-cane icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-walking-with-cane

  ```
  graph
  |> fontawesome_person_walking_with_cane({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_walking_with_cane(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_walking_with_cane(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_walking_with_cane(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the person-walking icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person-walking

  ```
  graph
  |> fontawesome_person_walking({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person_walking(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person_walking(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person_walking(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 460}, {50, 80}, opts)
  end
            
  @doc """
  Adds the person icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/person

  ```
  graph
  |> fontawesome_person({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_person(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_person(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_person(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 0}, {50, 80}, opts)
  end
            
  @doc """
  Adds the peseta-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/peseta-sign

  ```
  graph
  |> fontawesome_peseta_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_peseta_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_peseta_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_peseta_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 402}, {50, 67}, opts)
  end
            
  @doc """
  Adds the peso-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/peso-sign

  ```
  graph
  |> fontawesome_peso_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_peso_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_peso_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_peso_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 469}, {50, 67}, opts)
  end
            
  @doc """
  Adds the phone-flip icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/phone-flip

  ```
  graph
  |> fontawesome_phone_flip({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_phone_flip(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_phone_flip(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_phone_flip(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1423}, {50, 50}, opts)
  end
            
  @doc """
  Adds the phone-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/phone-slash

  ```
  graph
  |> fontawesome_phone_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_phone_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_phone_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_phone_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 360}, {50, 40}, opts)
  end
            
  @doc """
  Adds the phone-volume icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/phone-volume

  ```
  graph
  |> fontawesome_phone_volume({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_phone_volume(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_phone_volume(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_phone_volume(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 0}, {50, 50}, opts)
  end
            
  @doc """
  Adds the phone icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/phone

  ```
  graph
  |> fontawesome_phone({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_phone(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_phone(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_phone(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 50}, {50, 50}, opts)
  end
            
  @doc """
  Adds the photo-film icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/photo-film

  ```
  graph
  |> fontawesome_photo_film({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_photo_film(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_photo_film(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_photo_film(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 400}, {50, 40}, opts)
  end
            
  @doc """
  Adds the piggy-bank icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/piggy-bank

  ```
  graph
  |> fontawesome_piggy_bank({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_piggy_bank(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_piggy_bank(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_piggy_bank(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the pills icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pills

  ```
  graph
  |> fontawesome_pills({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pills(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pills(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pills(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the pizza-slice icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pizza-slice

  ```
  graph
  |> fontawesome_pizza_slice({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pizza_slice(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pizza_slice(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pizza_slice(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the place-of-worship icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/place-of-worship

  ```
  graph
  |> fontawesome_place_of_worship({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_place_of_worship(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_place_of_worship(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_place_of_worship(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 440}, {50, 40}, opts)
  end
            
  @doc """
  Adds the plane-arrival icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plane-arrival

  ```
  graph
  |> fontawesome_plane_arrival({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plane_arrival(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plane_arrival(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plane_arrival(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 480}, {50, 40}, opts)
  end
            
  @doc """
  Adds the plane-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plane-circle-check

  ```
  graph
  |> fontawesome_plane_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plane_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plane_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plane_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 520}, {50, 40}, opts)
  end
            
  @doc """
  Adds the plane-circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plane-circle-exclamation

  ```
  graph
  |> fontawesome_plane_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plane_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plane_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plane_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 560}, {50, 40}, opts)
  end
            
  @doc """
  Adds the plane-circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plane-circle-xmark

  ```
  graph
  |> fontawesome_plane_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plane_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plane_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plane_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 600}, {50, 40}, opts)
  end
            
  @doc """
  Adds the plane-departure icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plane-departure

  ```
  graph
  |> fontawesome_plane_departure({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plane_departure(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plane_departure(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plane_departure(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 640}, {50, 40}, opts)
  end
            
  @doc """
  Adds the plane-lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plane-lock

  ```
  graph
  |> fontawesome_plane_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plane_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plane_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plane_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 680}, {50, 40}, opts)
  end
            
  @doc """
  Adds the plane-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plane-slash

  ```
  graph
  |> fontawesome_plane_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plane_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plane_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plane_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 720}, {50, 40}, opts)
  end
            
  @doc """
  Adds the plane-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plane-up

  ```
  graph
  |> fontawesome_plane_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plane_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plane_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plane_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the plane icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plane

  ```
  graph
  |> fontawesome_plane({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plane(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plane(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plane(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the plant-wilt icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plant-wilt

  ```
  graph
  |> fontawesome_plant_wilt({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plant_wilt(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plant_wilt(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plant_wilt(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the plate-wheat icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plate-wheat

  ```
  graph
  |> fontawesome_plate_wheat({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plate_wheat(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plate_wheat(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plate_wheat(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the play icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/play

  ```
  graph
  |> fontawesome_play({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_play(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_play(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_play(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 536}, {50, 67}, opts)
  end
            
  @doc """
  Adds the plug-circle-bolt icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plug-circle-bolt

  ```
  graph
  |> fontawesome_plug_circle_bolt({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plug_circle_bolt(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plug_circle_bolt(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plug_circle_bolt(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the plug-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plug-circle-check

  ```
  graph
  |> fontawesome_plug_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plug_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plug_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plug_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the plug-circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plug-circle-exclamation

  ```
  graph
  |> fontawesome_plug_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plug_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plug_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plug_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the plug-circle-minus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plug-circle-minus

  ```
  graph
  |> fontawesome_plug_circle_minus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plug_circle_minus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plug_circle_minus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plug_circle_minus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the plug-circle-plus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plug-circle-plus

  ```
  graph
  |> fontawesome_plug_circle_plus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plug_circle_plus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plug_circle_plus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plug_circle_plus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the plug-circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plug-circle-xmark

  ```
  graph
  |> fontawesome_plug_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plug_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plug_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plug_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the plug icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plug

  ```
  graph
  |> fontawesome_plug({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plug(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plug(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plug(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 603}, {50, 67}, opts)
  end
            
  @doc """
  Adds the plus-minus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plus-minus

  ```
  graph
  |> fontawesome_plus_minus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plus_minus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plus_minus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plus_minus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 670}, {50, 67}, opts)
  end
            
  @doc """
  Adds the plus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/plus

  ```
  graph
  |> fontawesome_plus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_plus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_plus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_plus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the podcast icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/podcast

  ```
  graph
  |> fontawesome_podcast({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_podcast(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_podcast(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_podcast(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the poo-storm icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/poo-storm

  ```
  graph
  |> fontawesome_poo_storm({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_poo_storm(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_poo_storm(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_poo_storm(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the poo icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/poo

  ```
  graph
  |> fontawesome_poo({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_poo(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_poo(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_poo(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 300}, {50, 50}, opts)
  end
            
  @doc """
  Adds the poop icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/poop

  ```
  graph
  |> fontawesome_poop({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_poop(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_poop(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_poop(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 350}, {50, 50}, opts)
  end
            
  @doc """
  Adds the power-off icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/power-off

  ```
  graph
  |> fontawesome_power_off({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_power_off(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_power_off(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_power_off(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 400}, {50, 50}, opts)
  end
            
  @doc """
  Adds the prescription-bottle-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/prescription-bottle-medical

  ```
  graph
  |> fontawesome_prescription_bottle_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_prescription_bottle_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_prescription_bottle_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_prescription_bottle_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 737}, {50, 67}, opts)
  end
            
  @doc """
  Adds the prescription-bottle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/prescription-bottle

  ```
  graph
  |> fontawesome_prescription_bottle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_prescription_bottle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_prescription_bottle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_prescription_bottle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the prescription icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/prescription

  ```
  graph
  |> fontawesome_prescription({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_prescription(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_prescription(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_prescription(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the print icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/print

  ```
  graph
  |> fontawesome_print({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_print(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_print(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_print(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 450}, {50, 50}, opts)
  end
            
  @doc """
  Adds the pump-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pump-medical

  ```
  graph
  |> fontawesome_pump_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pump_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pump_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pump_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the pump-soap icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/pump-soap

  ```
  graph
  |> fontawesome_pump_soap({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_pump_soap(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_pump_soap(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_pump_soap(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the puzzle-piece icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/puzzle-piece

  ```
  graph
  |> fontawesome_puzzle_piece({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_puzzle_piece(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_puzzle_piece(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_puzzle_piece(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 500}, {50, 50}, opts)
  end
            
  @doc """
  Adds the q icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/q

  ```
  graph
  |> fontawesome_q({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_q(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_q(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_q(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the qrcode icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/qrcode

  ```
  graph
  |> fontawesome_qrcode({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_qrcode(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_qrcode(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_qrcode(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the question icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/question

  ```
  graph
  |> fontawesome_question({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_question(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_question(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_question(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 80}, {50, 80}, opts)
  end
            
  @doc """
  Adds the quote-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/quote-left

  ```
  graph
  |> fontawesome_quote_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_quote_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_quote_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_quote_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1002}, {50, 57}, opts)
  end
            
  @doc """
  Adds the quote-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/quote-right

  ```
  graph
  |> fontawesome_quote_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_quote_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_quote_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_quote_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 0}, {50, 57}, opts)
  end
            
  @doc """
  Adds the r icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/r

  ```
  graph
  |> fontawesome_r({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_r(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_r(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_r(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 160}, {50, 80}, opts)
  end
            
  @doc """
  Adds the radiation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/radiation

  ```
  graph
  |> fontawesome_radiation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_radiation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_radiation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_radiation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 550}, {50, 50}, opts)
  end
            
  @doc """
  Adds the radio icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/radio

  ```
  graph
  |> fontawesome_radio({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_radio(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_radio(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_radio(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 600}, {50, 50}, opts)
  end
            
  @doc """
  Adds the rainbow icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/rainbow

  ```
  graph
  |> fontawesome_rainbow({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_rainbow(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_rainbow(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_rainbow(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 760}, {50, 40}, opts)
  end
            
  @doc """
  Adds the ranking-star icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ranking-star

  ```
  graph
  |> fontawesome_ranking_star({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ranking_star(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ranking_star(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ranking_star(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 800}, {50, 40}, opts)
  end
            
  @doc """
  Adds the receipt icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/receipt

  ```
  graph
  |> fontawesome_receipt({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_receipt(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_receipt(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_receipt(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the record-vinyl icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/record-vinyl

  ```
  graph
  |> fontawesome_record_vinyl({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_record_vinyl(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_record_vinyl(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_record_vinyl(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 650}, {50, 50}, opts)
  end
            
  @doc """
  Adds the rectangle-ad icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/rectangle-ad

  ```
  graph
  |> fontawesome_rectangle_ad({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_rectangle_ad(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_rectangle_ad(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_rectangle_ad(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the rectangle-list icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/rectangle-list

  ```
  graph
  |> fontawesome_rectangle_list({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_rectangle_list(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_rectangle_list(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_rectangle_list(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the rectangle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/rectangle-xmark

  ```
  graph
  |> fontawesome_rectangle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_rectangle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_rectangle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_rectangle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 700}, {50, 50}, opts)
  end
            
  @doc """
  Adds the recycle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/recycle

  ```
  graph
  |> fontawesome_recycle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_recycle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_recycle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_recycle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 750}, {50, 50}, opts)
  end
            
  @doc """
  Adds the registered icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/registered

  ```
  graph
  |> fontawesome_registered({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_registered(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_registered(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_registered(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 800}, {50, 50}, opts)
  end
            
  @doc """
  Adds the repeat icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/repeat

  ```
  graph
  |> fontawesome_repeat({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_repeat(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_repeat(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_repeat(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 850}, {50, 50}, opts)
  end
            
  @doc """
  Adds the reply-all icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/reply-all

  ```
  graph
  |> fontawesome_reply_all({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_reply_all(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_reply_all(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_reply_all(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the reply icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/reply

  ```
  graph
  |> fontawesome_reply({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_reply(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_reply(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_reply(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 900}, {50, 50}, opts)
  end
            
  @doc """
  Adds the republican icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/republican

  ```
  graph
  |> fontawesome_republican({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_republican(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_republican(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_republican(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 840}, {50, 40}, opts)
  end
            
  @doc """
  Adds the restroom icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/restroom

  ```
  graph
  |> fontawesome_restroom({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_restroom(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_restroom(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_restroom(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 880}, {50, 40}, opts)
  end
            
  @doc """
  Adds the retweet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/retweet

  ```
  graph
  |> fontawesome_retweet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_retweet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_retweet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_retweet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the ribbon icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ribbon

  ```
  graph
  |> fontawesome_ribbon({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ribbon(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ribbon(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ribbon(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 57}, {50, 57}, opts)
  end
            
  @doc """
  Adds the right-from-bracket icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/right-from-bracket

  ```
  graph
  |> fontawesome_right_from_bracket({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_right_from_bracket(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_right_from_bracket(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_right_from_bracket(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 950}, {50, 50}, opts)
  end
            
  @doc """
  Adds the right-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/right-left

  ```
  graph
  |> fontawesome_right_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_right_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_right_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_right_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1000}, {50, 50}, opts)
  end
            
  @doc """
  Adds the right-long icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/right-long

  ```
  graph
  |> fontawesome_right_long({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_right_long(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_right_long(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_right_long(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1050}, {50, 50}, opts)
  end
            
  @doc """
  Adds the right-to-bracket icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/right-to-bracket

  ```
  graph
  |> fontawesome_right_to_bracket({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_right_to_bracket(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_right_to_bracket(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_right_to_bracket(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the ring icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ring

  ```
  graph
  |> fontawesome_ring({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ring(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ring(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ring(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the road-barrier icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/road-barrier

  ```
  graph
  |> fontawesome_road_barrier({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_road_barrier(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_road_barrier(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_road_barrier(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 920}, {50, 40}, opts)
  end
            
  @doc """
  Adds the road-bridge icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/road-bridge

  ```
  graph
  |> fontawesome_road_bridge({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_road_bridge(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_road_bridge(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_road_bridge(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 960}, {50, 40}, opts)
  end
            
  @doc """
  Adds the road-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/road-circle-check

  ```
  graph
  |> fontawesome_road_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_road_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_road_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_road_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1000}, {50, 40}, opts)
  end
            
  @doc """
  Adds the road-circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/road-circle-exclamation

  ```
  graph
  |> fontawesome_road_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_road_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_road_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_road_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1040}, {50, 40}, opts)
  end
            
  @doc """
  Adds the road-circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/road-circle-xmark

  ```
  graph
  |> fontawesome_road_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_road_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_road_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_road_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1080}, {50, 40}, opts)
  end
            
  @doc """
  Adds the road-lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/road-lock

  ```
  graph
  |> fontawesome_road_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_road_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_road_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_road_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1120}, {50, 40}, opts)
  end
            
  @doc """
  Adds the road-spikes icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/road-spikes

  ```
  graph
  |> fontawesome_road_spikes({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_road_spikes(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_road_spikes(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_road_spikes(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1160}, {50, 40}, opts)
  end
            
  @doc """
  Adds the road icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/road

  ```
  graph
  |> fontawesome_road({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_road(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_road(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_road(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the robot icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/robot

  ```
  graph
  |> fontawesome_robot({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_robot(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_robot(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_robot(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1200}, {50, 40}, opts)
  end
            
  @doc """
  Adds the rocket icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/rocket

  ```
  graph
  |> fontawesome_rocket({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_rocket(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_rocket(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_rocket(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the rotate-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/rotate-left

  ```
  graph
  |> fontawesome_rotate_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_rotate_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_rotate_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_rotate_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the rotate-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/rotate-right

  ```
  graph
  |> fontawesome_rotate_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_rotate_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_rotate_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_rotate_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1300}, {50, 50}, opts)
  end
            
  @doc """
  Adds the rotate icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/rotate

  ```
  graph
  |> fontawesome_rotate({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_rotate(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_rotate(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_rotate(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1350}, {50, 50}, opts)
  end
            
  @doc """
  Adds the route icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/route

  ```
  graph
  |> fontawesome_route({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_route(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_route(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_route(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1400}, {50, 50}, opts)
  end
            
  @doc """
  Adds the rss icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/rss

  ```
  graph
  |> fontawesome_rss({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_rss(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_rss(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_rss(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 114}, {50, 57}, opts)
  end
            
  @doc """
  Adds the ruble-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ruble-sign

  ```
  graph
  |> fontawesome_ruble_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ruble_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ruble_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ruble_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the rug icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/rug

  ```
  graph
  |> fontawesome_rug({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_rug(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_rug(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_rug(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1240}, {50, 40}, opts)
  end
            
  @doc """
  Adds the ruler-combined icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ruler-combined

  ```
  graph
  |> fontawesome_ruler_combined({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ruler_combined(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ruler_combined(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ruler_combined(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the ruler-horizontal icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ruler-horizontal

  ```
  graph
  |> fontawesome_ruler_horizontal({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ruler_horizontal(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ruler_horizontal(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ruler_horizontal(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1280}, {50, 40}, opts)
  end
            
  @doc """
  Adds the ruler-vertical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ruler-vertical

  ```
  graph
  |> fontawesome_ruler_vertical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ruler_vertical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ruler_vertical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ruler_vertical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 200}, {50, 100}, opts)
  end
            
  @doc """
  Adds the ruler icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ruler

  ```
  graph
  |> fontawesome_ruler({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ruler(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ruler(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ruler(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the rupee-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/rupee-sign

  ```
  graph
  |> fontawesome_rupee_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_rupee_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_rupee_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_rupee_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 171}, {50, 57}, opts)
  end
            
  @doc """
  Adds the rupiah-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/rupiah-sign

  ```
  graph
  |> fontawesome_rupiah_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_rupiah_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_rupiah_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_rupiah_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the s icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/s

  ```
  graph
  |> fontawesome_s({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_s(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_s(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_s(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 240}, {50, 80}, opts)
  end
            
  @doc """
  Adds the sack-dollar icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sack-dollar

  ```
  graph
  |> fontawesome_sack_dollar({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sack_dollar(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sack_dollar(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sack_dollar(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the sack-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sack-xmark

  ```
  graph
  |> fontawesome_sack_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sack_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sack_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sack_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the sailboat icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sailboat

  ```
  graph
  |> fontawesome_sailboat({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sailboat(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sailboat(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sailboat(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the satellite-dish icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/satellite-dish

  ```
  graph
  |> fontawesome_satellite_dish({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_satellite_dish(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_satellite_dish(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_satellite_dish(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the satellite icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/satellite

  ```
  graph
  |> fontawesome_satellite({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_satellite(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_satellite(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_satellite(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the scale-balanced icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/scale-balanced

  ```
  graph
  |> fontawesome_scale_balanced({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_scale_balanced(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_scale_balanced(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_scale_balanced(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1320}, {50, 40}, opts)
  end
            
  @doc """
  Adds the scale-unbalanced-flip icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/scale-unbalanced-flip

  ```
  graph
  |> fontawesome_scale_unbalanced_flip({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_scale_unbalanced_flip(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_scale_unbalanced_flip(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_scale_unbalanced_flip(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1360}, {50, 40}, opts)
  end
            
  @doc """
  Adds the scale-unbalanced icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/scale-unbalanced

  ```
  graph
  |> fontawesome_scale_unbalanced({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_scale_unbalanced(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_scale_unbalanced(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_scale_unbalanced(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1400}, {50, 40}, opts)
  end
            
  @doc """
  Adds the school-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/school-circle-check

  ```
  graph
  |> fontawesome_school_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_school_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_school_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_school_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1440}, {50, 40}, opts)
  end
            
  @doc """
  Adds the school-circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/school-circle-exclamation

  ```
  graph
  |> fontawesome_school_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_school_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_school_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_school_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1480}, {50, 40}, opts)
  end
            
  @doc """
  Adds the school-circle-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/school-circle-xmark

  ```
  graph
  |> fontawesome_school_circle_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_school_circle_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_school_circle_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_school_circle_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1520}, {50, 40}, opts)
  end
            
  @doc """
  Adds the school-flag icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/school-flag

  ```
  graph
  |> fontawesome_school_flag({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_school_flag(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_school_flag(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_school_flag(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the school-lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/school-lock

  ```
  graph
  |> fontawesome_school_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_school_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_school_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_school_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1560}, {50, 40}, opts)
  end
            
  @doc """
  Adds the school icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/school

  ```
  graph
  |> fontawesome_school({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_school(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_school(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_school(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1600}, {50, 40}, opts)
  end
            
  @doc """
  Adds the scissors icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/scissors

  ```
  graph
  |> fontawesome_scissors({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_scissors(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_scissors(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_scissors(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the screwdriver-wrench icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/screwdriver-wrench

  ```
  graph
  |> fontawesome_screwdriver_wrench({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_screwdriver_wrench(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_screwdriver_wrench(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_screwdriver_wrench(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the screwdriver icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/screwdriver

  ```
  graph
  |> fontawesome_screwdriver({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_screwdriver(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_screwdriver(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_screwdriver(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the scroll-torah icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/scroll-torah

  ```
  graph
  |> fontawesome_scroll_torah({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_scroll_torah(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_scroll_torah(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_scroll_torah(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1640}, {50, 40}, opts)
  end
            
  @doc """
  Adds the scroll icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/scroll

  ```
  graph
  |> fontawesome_scroll({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_scroll(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_scroll(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_scroll(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1661}, {50, 44}, opts)
  end
            
  @doc """
  Adds the sd-card icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sd-card

  ```
  graph
  |> fontawesome_sd_card({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sd_card(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sd_card(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sd_card(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the section icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/section

  ```
  graph
  |> fontawesome_section({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_section(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_section(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_section(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 200}, {50, 100}, opts)
  end
            
  @doc """
  Adds the seedling icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/seedling

  ```
  graph
  |> fontawesome_seedling({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_seedling(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_seedling(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_seedling(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the server icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/server

  ```
  graph
  |> fontawesome_server({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_server(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_server(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_server(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the shapes icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shapes

  ```
  graph
  |> fontawesome_shapes({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shapes(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shapes(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shapes(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the share-from-square icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/share-from-square

  ```
  graph
  |> fontawesome_share_from_square({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_share_from_square(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_share_from_square(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_share_from_square(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the share-nodes icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/share-nodes

  ```
  graph
  |> fontawesome_share_nodes({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_share_nodes(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_share_nodes(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_share_nodes(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 228}, {50, 57}, opts)
  end
            
  @doc """
  Adds the share icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/share

  ```
  graph
  |> fontawesome_share({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_share(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_share(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_share(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the sheet-plastic icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sheet-plastic

  ```
  graph
  |> fontawesome_sheet_plastic({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sheet_plastic(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sheet_plastic(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sheet_plastic(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the shekel-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shekel-sign

  ```
  graph
  |> fontawesome_shekel_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shekel_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shekel_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shekel_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 285}, {50, 57}, opts)
  end
            
  @doc """
  Adds the shield-cat icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shield-cat

  ```
  graph
  |> fontawesome_shield_cat({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shield_cat(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shield_cat(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shield_cat(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the shield-dog icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shield-dog

  ```
  graph
  |> fontawesome_shield_dog({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shield_dog(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shield_dog(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shield_dog(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the shield-halved icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shield-halved

  ```
  graph
  |> fontawesome_shield_halved({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shield_halved(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shield_halved(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shield_halved(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the shield-heart icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shield-heart

  ```
  graph
  |> fontawesome_shield_heart({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shield_heart(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shield_heart(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shield_heart(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the shield-virus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shield-virus

  ```
  graph
  |> fontawesome_shield_virus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shield_virus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shield_virus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shield_virus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the shield icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shield

  ```
  graph
  |> fontawesome_shield({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shield(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shield(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shield(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the ship icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ship

  ```
  graph
  |> fontawesome_ship({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ship(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ship(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ship(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the shirt icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shirt

  ```
  graph
  |> fontawesome_shirt({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shirt(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shirt(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shirt(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1680}, {50, 40}, opts)
  end
            
  @doc """
  Adds the shoe-prints icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shoe-prints

  ```
  graph
  |> fontawesome_shoe_prints({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shoe_prints(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shoe_prints(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shoe_prints(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1720}, {50, 40}, opts)
  end
            
  @doc """
  Adds the shop-lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shop-lock

  ```
  graph
  |> fontawesome_shop_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shop_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shop_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shop_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1760}, {50, 40}, opts)
  end
            
  @doc """
  Adds the shop-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shop-slash

  ```
  graph
  |> fontawesome_shop_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shop_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shop_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shop_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the shop icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shop

  ```
  graph
  |> fontawesome_shop({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shop(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shop(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shop(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the shower icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shower

  ```
  graph
  |> fontawesome_shower({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shower(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shower(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shower(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the shrimp icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shrimp

  ```
  graph
  |> fontawesome_shrimp({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shrimp(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shrimp(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shrimp(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the shuffle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shuffle

  ```
  graph
  |> fontawesome_shuffle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shuffle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shuffle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shuffle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the shuttle-space icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/shuttle-space

  ```
  graph
  |> fontawesome_shuttle_space({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_shuttle_space(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_shuttle_space(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_shuttle_space(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the sign-hanging icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sign-hanging

  ```
  graph
  |> fontawesome_sign_hanging({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sign_hanging(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sign_hanging(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sign_hanging(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the signal icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/signal

  ```
  graph
  |> fontawesome_signal({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_signal(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_signal(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_signal(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the signature icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/signature

  ```
  graph
  |> fontawesome_signature({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_signature(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_signature(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_signature(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the signs-post icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/signs-post

  ```
  graph
  |> fontawesome_signs_post({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_signs_post(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_signs_post(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_signs_post(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the sim-card icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sim-card

  ```
  graph
  |> fontawesome_sim_card({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sim_card(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sim_card(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sim_card(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the sink icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sink

  ```
  graph
  |> fontawesome_sink({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sink(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sink(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sink(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the sitemap icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sitemap

  ```
  graph
  |> fontawesome_sitemap({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sitemap(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sitemap(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sitemap(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the skull-crossbones icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/skull-crossbones

  ```
  graph
  |> fontawesome_skull_crossbones({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_skull_crossbones(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_skull_crossbones(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_skull_crossbones(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 342}, {50, 57}, opts)
  end
            
  @doc """
  Adds the skull icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/skull

  ```
  graph
  |> fontawesome_skull({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_skull(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_skull(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_skull(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/slash

  ```
  graph
  |> fontawesome_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the sleigh icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sleigh

  ```
  graph
  |> fontawesome_sleigh({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sleigh(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sleigh(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sleigh(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the sliders icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sliders

  ```
  graph
  |> fontawesome_sliders({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sliders(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sliders(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sliders(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the smog icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/smog

  ```
  graph
  |> fontawesome_smog({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_smog(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_smog(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_smog(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the smoking icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/smoking

  ```
  graph
  |> fontawesome_smoking({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_smoking(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_smoking(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_smoking(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the snowflake icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/snowflake

  ```
  graph
  |> fontawesome_snowflake({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_snowflake(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_snowflake(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_snowflake(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 399}, {50, 57}, opts)
  end
            
  @doc """
  Adds the snowman icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/snowman

  ```
  graph
  |> fontawesome_snowman({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_snowman(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_snowman(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_snowman(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the snowplow icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/snowplow

  ```
  graph
  |> fontawesome_snowplow({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_snowplow(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_snowplow(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_snowplow(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the soap icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/soap

  ```
  graph
  |> fontawesome_soap({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_soap(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_soap(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_soap(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the socks icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/socks

  ```
  graph
  |> fontawesome_socks({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_socks(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_socks(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_socks(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1473}, {50, 50}, opts)
  end
            
  @doc """
  Adds the solar-panel icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/solar-panel

  ```
  graph
  |> fontawesome_solar_panel({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_solar_panel(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_solar_panel(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_solar_panel(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the sort-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sort-down

  ```
  graph
  |> fontawesome_sort_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sort_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sort_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sort_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 320}, {50, 80}, opts)
  end
            
  @doc """
  Adds the sort-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sort-up

  ```
  graph
  |> fontawesome_sort_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sort_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sort_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sort_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 400}, {50, 80}, opts)
  end
            
  @doc """
  Adds the sort icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sort

  ```
  graph
  |> fontawesome_sort({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sort(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sort(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sort(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 0}, {50, 80}, opts)
  end
            
  @doc """
  Adds the spa icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/spa

  ```
  graph
  |> fontawesome_spa({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_spa(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_spa(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_spa(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the spaghetti-monster-flying icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/spaghetti-monster-flying

  ```
  graph
  |> fontawesome_spaghetti_monster_flying({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_spaghetti_monster_flying(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_spaghetti_monster_flying(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_spaghetti_monster_flying(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the spell-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/spell-check

  ```
  graph
  |> fontawesome_spell_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_spell_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_spell_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_spell_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the spider icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/spider

  ```
  graph
  |> fontawesome_spider({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_spider(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_spider(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_spider(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 0}, {50, 50}, opts)
  end
            
  @doc """
  Adds the spinner icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/spinner

  ```
  graph
  |> fontawesome_spinner({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_spinner(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_spinner(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_spinner(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 50}, {50, 50}, opts)
  end
            
  @doc """
  Adds the splotch icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/splotch

  ```
  graph
  |> fontawesome_splotch({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_splotch(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_splotch(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_splotch(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the spoon icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/spoon

  ```
  graph
  |> fontawesome_spoon({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_spoon(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_spoon(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_spoon(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the spray-can-sparkles icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/spray-can-sparkles

  ```
  graph
  |> fontawesome_spray_can_sparkles({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_spray_can_sparkles(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_spray_can_sparkles(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_spray_can_sparkles(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the spray-can icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/spray-can

  ```
  graph
  |> fontawesome_spray_can({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_spray_can(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_spray_can(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_spray_can(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the square-arrow-up-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-arrow-up-right

  ```
  graph
  |> fontawesome_square_arrow_up_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_arrow_up_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_arrow_up_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_arrow_up_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 456}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-caret-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-caret-down

  ```
  graph
  |> fontawesome_square_caret_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_caret_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_caret_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_caret_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 513}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-caret-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-caret-left

  ```
  graph
  |> fontawesome_square_caret_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_caret_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_caret_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_caret_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 570}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-caret-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-caret-right

  ```
  graph
  |> fontawesome_square_caret_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_caret_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_caret_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_caret_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 627}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-caret-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-caret-up

  ```
  graph
  |> fontawesome_square_caret_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_caret_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_caret_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_caret_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 684}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-check

  ```
  graph
  |> fontawesome_square_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 741}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-envelope icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-envelope

  ```
  graph
  |> fontawesome_square_envelope({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_envelope(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_envelope(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_envelope(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 798}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-full icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-full

  ```
  graph
  |> fontawesome_square_full({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_full(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_full(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_full(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 300}, {50, 50}, opts)
  end
            
  @doc """
  Adds the square-h icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-h

  ```
  graph
  |> fontawesome_square_h({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_h(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_h(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_h(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 855}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-minus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-minus

  ```
  graph
  |> fontawesome_square_minus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_minus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_minus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_minus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 912}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-nfi icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-nfi

  ```
  graph
  |> fontawesome_square_nfi({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_nfi(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_nfi(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_nfi(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 969}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-parking icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-parking

  ```
  graph
  |> fontawesome_square_parking({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_parking(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_parking(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_parking(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-pen icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-pen

  ```
  graph
  |> fontawesome_square_pen({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_pen(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_pen(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_pen(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-person-confined icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-person-confined

  ```
  graph
  |> fontawesome_square_person_confined({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_person_confined(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_person_confined(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_person_confined(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-phone-flip icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-phone-flip

  ```
  graph
  |> fontawesome_square_phone_flip({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_phone_flip(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_phone_flip(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_phone_flip(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-phone icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-phone

  ```
  graph
  |> fontawesome_square_phone({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_phone(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_phone(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_phone(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-plus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-plus

  ```
  graph
  |> fontawesome_square_plus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_plus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_plus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_plus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-poll-horizontal icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-poll-horizontal

  ```
  graph
  |> fontawesome_square_poll_horizontal({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_poll_horizontal(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_poll_horizontal(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_poll_horizontal(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-poll-vertical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-poll-vertical

  ```
  graph
  |> fontawesome_square_poll_vertical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_poll_vertical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_poll_vertical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_poll_vertical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-root-variable icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-root-variable

  ```
  graph
  |> fontawesome_square_root_variable({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_root_variable(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_root_variable(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_root_variable(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the square-rss icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-rss

  ```
  graph
  |> fontawesome_square_rss({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_rss(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_rss(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_rss(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-share-nodes icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-share-nodes

  ```
  graph
  |> fontawesome_square_share_nodes({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_share_nodes(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_share_nodes(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_share_nodes(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-up-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-up-right

  ```
  graph
  |> fontawesome_square_up_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_up_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_up_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_up_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-virus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-virus

  ```
  graph
  |> fontawesome_square_virus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_virus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_virus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_virus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square-xmark

  ```
  graph
  |> fontawesome_square_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the square icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/square

  ```
  graph
  |> fontawesome_square({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_square(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_square(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_square(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the staff-snake icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/staff-snake

  ```
  graph
  |> fontawesome_staff_snake({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_staff_snake(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_staff_snake(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_staff_snake(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the stairs icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/stairs

  ```
  graph
  |> fontawesome_stairs({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_stairs(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_stairs(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_stairs(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the stamp icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/stamp

  ```
  graph
  |> fontawesome_stamp({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_stamp(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_stamp(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_stamp(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 350}, {50, 50}, opts)
  end
            
  @doc """
  Adds the stapler icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/stapler

  ```
  graph
  |> fontawesome_stapler({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_stapler(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_stapler(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_stapler(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the star-and-crescent icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/star-and-crescent

  ```
  graph
  |> fontawesome_star_and_crescent({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_star_and_crescent(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_star_and_crescent(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_star_and_crescent(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 400}, {50, 50}, opts)
  end
            
  @doc """
  Adds the star-half-stroke icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/star-half-stroke

  ```
  graph
  |> fontawesome_star_half_stroke({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_star_half_stroke(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_star_half_stroke(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_star_half_stroke(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the star-half icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/star-half

  ```
  graph
  |> fontawesome_star_half({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_star_half(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_star_half(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_star_half(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the star-of-david icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/star-of-david

  ```
  graph
  |> fontawesome_star_of_david({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_star_of_david(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_star_of_david(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_star_of_david(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 450}, {50, 50}, opts)
  end
            
  @doc """
  Adds the star-of-life icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/star-of-life

  ```
  graph
  |> fontawesome_star_of_life({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_star_of_life(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_star_of_life(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_star_of_life(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 500}, {50, 50}, opts)
  end
            
  @doc """
  Adds the star icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/star

  ```
  graph
  |> fontawesome_star({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_star(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_star(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_star(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the sterling-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sterling-sign

  ```
  graph
  |> fontawesome_sterling_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sterling_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sterling_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sterling_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 80}, {50, 80}, opts)
  end
            
  @doc """
  Adds the stethoscope icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/stethoscope

  ```
  graph
  |> fontawesome_stethoscope({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_stethoscope(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_stethoscope(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_stethoscope(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the stop icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/stop

  ```
  graph
  |> fontawesome_stop({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_stop(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_stop(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_stop(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the stopwatch-20 icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/stopwatch-20

  ```
  graph
  |> fontawesome_stopwatch_20({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_stopwatch_20(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_stopwatch_20(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_stopwatch_20(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the stopwatch icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/stopwatch

  ```
  graph
  |> fontawesome_stopwatch({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_stopwatch(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_stopwatch(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_stopwatch(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the store-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/store-slash

  ```
  graph
  |> fontawesome_store_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_store_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_store_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_store_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the store icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/store

  ```
  graph
  |> fontawesome_store({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_store(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_store(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_store(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the street-view icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/street-view

  ```
  graph
  |> fontawesome_street_view({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_street_view(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_street_view(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_street_view(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 550}, {50, 50}, opts)
  end
            
  @doc """
  Adds the strikethrough icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/strikethrough

  ```
  graph
  |> fontawesome_strikethrough({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_strikethrough(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_strikethrough(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_strikethrough(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 600}, {50, 50}, opts)
  end
            
  @doc """
  Adds the stroopwafel icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/stroopwafel

  ```
  graph
  |> fontawesome_stroopwafel({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_stroopwafel(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_stroopwafel(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_stroopwafel(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 650}, {50, 50}, opts)
  end
            
  @doc """
  Adds the subscript icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/subscript

  ```
  graph
  |> fontawesome_subscript({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_subscript(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_subscript(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_subscript(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 700}, {50, 50}, opts)
  end
            
  @doc """
  Adds the suitcase-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/suitcase-medical

  ```
  graph
  |> fontawesome_suitcase_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_suitcase_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_suitcase_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_suitcase_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 750}, {50, 50}, opts)
  end
            
  @doc """
  Adds the suitcase-rolling icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/suitcase-rolling

  ```
  graph
  |> fontawesome_suitcase_rolling({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_suitcase_rolling(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_suitcase_rolling(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_suitcase_rolling(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the suitcase icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/suitcase

  ```
  graph
  |> fontawesome_suitcase({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_suitcase(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_suitcase(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_suitcase(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 800}, {50, 50}, opts)
  end
            
  @doc """
  Adds the sun-plant-wilt icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sun-plant-wilt

  ```
  graph
  |> fontawesome_sun_plant_wilt({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sun_plant_wilt(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sun_plant_wilt(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sun_plant_wilt(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the sun icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/sun

  ```
  graph
  |> fontawesome_sun({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_sun(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_sun(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_sun(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 850}, {50, 50}, opts)
  end
            
  @doc """
  Adds the superscript icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/superscript

  ```
  graph
  |> fontawesome_superscript({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_superscript(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_superscript(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_superscript(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 900}, {50, 50}, opts)
  end
            
  @doc """
  Adds the swatchbook icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/swatchbook

  ```
  graph
  |> fontawesome_swatchbook({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_swatchbook(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_swatchbook(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_swatchbook(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 950}, {50, 50}, opts)
  end
            
  @doc """
  Adds the synagogue icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/synagogue

  ```
  graph
  |> fontawesome_synagogue({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_synagogue(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_synagogue(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_synagogue(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the syringe icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/syringe

  ```
  graph
  |> fontawesome_syringe({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_syringe(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_syringe(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_syringe(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1000}, {50, 50}, opts)
  end
            
  @doc """
  Adds the t icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/t

  ```
  graph
  |> fontawesome_t({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_t(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_t(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_t(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the table-cells-column-lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/table-cells-column-lock

  ```
  graph
  |> fontawesome_table_cells_column_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_table_cells_column_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_table_cells_column_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_table_cells_column_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the table-cells-large icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/table-cells-large

  ```
  graph
  |> fontawesome_table_cells_large({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_table_cells_large(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_table_cells_large(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_table_cells_large(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1050}, {50, 50}, opts)
  end
            
  @doc """
  Adds the table-cells-row-lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/table-cells-row-lock

  ```
  graph
  |> fontawesome_table_cells_row_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_table_cells_row_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_table_cells_row_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_table_cells_row_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the table-cells-row-unlock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/table-cells-row-unlock

  ```
  graph
  |> fontawesome_table_cells_row_unlock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_table_cells_row_unlock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_table_cells_row_unlock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_table_cells_row_unlock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the table-cells icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/table-cells

  ```
  graph
  |> fontawesome_table_cells({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_table_cells(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_table_cells(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_table_cells(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the table-columns icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/table-columns

  ```
  graph
  |> fontawesome_table_columns({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_table_columns(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_table_columns(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_table_columns(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the table-list icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/table-list

  ```
  graph
  |> fontawesome_table_list({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_table_list(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_table_list(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_table_list(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the table-tennis-paddle-ball icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/table-tennis-paddle-ball

  ```
  graph
  |> fontawesome_table_tennis_paddle_ball({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_table_tennis_paddle_ball(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_table_tennis_paddle_ball(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_table_tennis_paddle_ball(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the table icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/table

  ```
  graph
  |> fontawesome_table({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_table(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_table(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_table(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1300}, {50, 50}, opts)
  end
            
  @doc """
  Adds the tablet-button icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tablet-button

  ```
  graph
  |> fontawesome_tablet_button({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tablet_button(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tablet_button(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tablet_button(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the tablet-screen-button icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tablet-screen-button

  ```
  graph
  |> fontawesome_tablet_screen_button({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tablet_screen_button(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tablet_screen_button(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tablet_screen_button(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the tablet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tablet

  ```
  graph
  |> fontawesome_tablet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tablet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tablet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tablet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the tablets icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tablets

  ```
  graph
  |> fontawesome_tablets({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tablets(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tablets(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tablets(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the tachograph-digital icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tachograph-digital

  ```
  graph
  |> fontawesome_tachograph_digital({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tachograph_digital(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tachograph_digital(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tachograph_digital(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the tag icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tag

  ```
  graph
  |> fontawesome_tag({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tag(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tag(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tag(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the tags icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tags

  ```
  graph
  |> fontawesome_tags({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tags(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tags(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tags(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1350}, {50, 50}, opts)
  end
            
  @doc """
  Adds the tape icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tape

  ```
  graph
  |> fontawesome_tape({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tape(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tape(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tape(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the tarp-droplet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tarp-droplet

  ```
  graph
  |> fontawesome_tarp_droplet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tarp_droplet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tarp_droplet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tarp_droplet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the tarp icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tarp

  ```
  graph
  |> fontawesome_tarp({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tarp(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tarp(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tarp(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the taxi icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/taxi

  ```
  graph
  |> fontawesome_taxi({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_taxi(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_taxi(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_taxi(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1400}, {50, 50}, opts)
  end
            
  @doc """
  Adds the teeth-open icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/teeth-open

  ```
  graph
  |> fontawesome_teeth_open({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_teeth_open(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_teeth_open(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_teeth_open(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the teeth icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/teeth

  ```
  graph
  |> fontawesome_teeth({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_teeth(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_teeth(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_teeth(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the temperature-arrow-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/temperature-arrow-down

  ```
  graph
  |> fontawesome_temperature_arrow_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_temperature_arrow_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_temperature_arrow_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_temperature_arrow_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the temperature-arrow-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/temperature-arrow-up

  ```
  graph
  |> fontawesome_temperature_arrow_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_temperature_arrow_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_temperature_arrow_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_temperature_arrow_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the temperature-empty icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/temperature-empty

  ```
  graph
  |> fontawesome_temperature_empty({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_temperature_empty(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_temperature_empty(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_temperature_empty(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 160}, {50, 80}, opts)
  end
            
  @doc """
  Adds the temperature-full icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/temperature-full

  ```
  graph
  |> fontawesome_temperature_full({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_temperature_full(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_temperature_full(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_temperature_full(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 240}, {50, 80}, opts)
  end
            
  @doc """
  Adds the temperature-half icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/temperature-half

  ```
  graph
  |> fontawesome_temperature_half({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_temperature_half(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_temperature_half(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_temperature_half(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 320}, {50, 80}, opts)
  end
            
  @doc """
  Adds the temperature-high icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/temperature-high

  ```
  graph
  |> fontawesome_temperature_high({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_temperature_high(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_temperature_high(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_temperature_high(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1450}, {50, 50}, opts)
  end
            
  @doc """
  Adds the temperature-low icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/temperature-low

  ```
  graph
  |> fontawesome_temperature_low({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_temperature_low(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_temperature_low(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_temperature_low(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the temperature-quarter icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/temperature-quarter

  ```
  graph
  |> fontawesome_temperature_quarter({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_temperature_quarter(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_temperature_quarter(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_temperature_quarter(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 400}, {50, 80}, opts)
  end
            
  @doc """
  Adds the temperature-three-quarters icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/temperature-three-quarters

  ```
  graph
  |> fontawesome_temperature_three_quarters({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_temperature_three_quarters(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_temperature_three_quarters(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_temperature_three_quarters(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 540}, {50, 80}, opts)
  end
            
  @doc """
  Adds the tenge-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tenge-sign

  ```
  graph
  |> fontawesome_tenge_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tenge_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tenge_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tenge_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the tent-arrow-down-to-line icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tent-arrow-down-to-line

  ```
  graph
  |> fontawesome_tent_arrow_down_to_line({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tent_arrow_down_to_line(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tent_arrow_down_to_line(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tent_arrow_down_to_line(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the tent-arrow-left-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tent-arrow-left-right

  ```
  graph
  |> fontawesome_tent_arrow_left_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tent_arrow_left_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tent_arrow_left_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tent_arrow_left_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the tent-arrow-turn-left icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tent-arrow-turn-left

  ```
  graph
  |> fontawesome_tent_arrow_turn_left({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tent_arrow_turn_left(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tent_arrow_turn_left(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tent_arrow_turn_left(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the tent-arrows-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tent-arrows-down

  ```
  graph
  |> fontawesome_tent_arrows_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tent_arrows_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tent_arrows_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tent_arrows_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the tent icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tent

  ```
  graph
  |> fontawesome_tent({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tent(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tent(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tent(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the tents icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tents

  ```
  graph
  |> fontawesome_tents({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tents(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tents(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tents(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the terminal icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/terminal

  ```
  graph
  |> fontawesome_terminal({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_terminal(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_terminal(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_terminal(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the text-height icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/text-height

  ```
  graph
  |> fontawesome_text_height({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_text_height(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_text_height(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_text_height(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the text-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/text-slash

  ```
  graph
  |> fontawesome_text_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_text_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_text_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_text_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the text-width icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/text-width

  ```
  graph
  |> fontawesome_text_width({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_text_width(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_text_width(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_text_width(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the thermometer icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/thermometer

  ```
  graph
  |> fontawesome_thermometer({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_thermometer(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_thermometer(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_thermometer(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the thumbs-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/thumbs-down

  ```
  graph
  |> fontawesome_thumbs_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_thumbs_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_thumbs_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_thumbs_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the thumbs-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/thumbs-up

  ```
  graph
  |> fontawesome_thumbs_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_thumbs_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_thumbs_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_thumbs_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the thumbtack-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/thumbtack-slash

  ```
  graph
  |> fontawesome_thumbtack_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_thumbtack_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_thumbtack_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_thumbtack_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the thumbtack icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/thumbtack

  ```
  graph
  |> fontawesome_thumbtack({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_thumbtack(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_thumbtack(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_thumbtack(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the ticket-simple icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ticket-simple

  ```
  graph
  |> fontawesome_ticket_simple({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ticket_simple(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ticket_simple(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ticket_simple(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the ticket icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/ticket

  ```
  graph
  |> fontawesome_ticket({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_ticket(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_ticket(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_ticket(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the timeline icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/timeline

  ```
  graph
  |> fontawesome_timeline({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_timeline(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_timeline(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_timeline(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the toggle-off icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/toggle-off

  ```
  graph
  |> fontawesome_toggle_off({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_toggle_off(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_toggle_off(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_toggle_off(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the toggle-on icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/toggle-on

  ```
  graph
  |> fontawesome_toggle_on({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_toggle_on(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_toggle_on(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_toggle_on(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the toilet-paper-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/toilet-paper-slash

  ```
  graph
  |> fontawesome_toilet_paper_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_toilet_paper_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_toilet_paper_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_toilet_paper_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the toilet-paper icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/toilet-paper

  ```
  graph
  |> fontawesome_toilet_paper({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_toilet_paper(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_toilet_paper(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_toilet_paper(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the toilet-portable icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/toilet-portable

  ```
  graph
  |> fontawesome_toilet_portable({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_toilet_portable(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_toilet_portable(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_toilet_portable(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 540}, {50, 80}, opts)
  end
            
  @doc """
  Adds the toilet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/toilet

  ```
  graph
  |> fontawesome_toilet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_toilet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_toilet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_toilet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the toilets-portable icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/toilets-portable

  ```
  graph
  |> fontawesome_toilets_portable({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_toilets_portable(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_toilets_portable(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_toilets_portable(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the toolbox icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/toolbox

  ```
  graph
  |> fontawesome_toolbox({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_toolbox(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_toolbox(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_toolbox(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the tooth icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tooth

  ```
  graph
  |> fontawesome_tooth({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tooth(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tooth(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tooth(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1059}, {50, 57}, opts)
  end
            
  @doc """
  Adds the torii-gate icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/torii-gate

  ```
  graph
  |> fontawesome_torii_gate({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_torii_gate(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_torii_gate(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_torii_gate(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the tornado icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tornado

  ```
  graph
  |> fontawesome_tornado({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tornado(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tornado(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tornado(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 0}, {50, 57}, opts)
  end
            
  @doc """
  Adds the tower-broadcast icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tower-broadcast

  ```
  graph
  |> fontawesome_tower_broadcast({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tower_broadcast(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tower_broadcast(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tower_broadcast(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the tower-cell icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tower-cell

  ```
  graph
  |> fontawesome_tower_cell({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tower_cell(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tower_cell(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tower_cell(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the tower-observation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tower-observation

  ```
  graph
  |> fontawesome_tower_observation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tower_observation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tower_observation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tower_observation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the tractor icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tractor

  ```
  graph
  |> fontawesome_tractor({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tractor(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tractor(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tractor(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the trademark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/trademark

  ```
  graph
  |> fontawesome_trademark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_trademark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_trademark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_trademark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the traffic-light icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/traffic-light

  ```
  graph
  |> fontawesome_traffic_light({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_traffic_light(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_traffic_light(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_traffic_light(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 540}, {50, 80}, opts)
  end
            
  @doc """
  Adds the trailer icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/trailer

  ```
  graph
  |> fontawesome_trailer({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_trailer(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_trailer(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_trailer(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the train-subway icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/train-subway

  ```
  graph
  |> fontawesome_train_subway({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_train_subway(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_train_subway(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_train_subway(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 57}, {50, 57}, opts)
  end
            
  @doc """
  Adds the train-tram icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/train-tram

  ```
  graph
  |> fontawesome_train_tram({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_train_tram(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_train_tram(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_train_tram(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 114}, {50, 57}, opts)
  end
            
  @doc """
  Adds the train icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/train

  ```
  graph
  |> fontawesome_train({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_train(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_train(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_train(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 171}, {50, 57}, opts)
  end
            
  @doc """
  Adds the transgender icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/transgender

  ```
  graph
  |> fontawesome_transgender({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_transgender(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_transgender(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_transgender(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the trash-arrow-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/trash-arrow-up

  ```
  graph
  |> fontawesome_trash_arrow_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_trash_arrow_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_trash_arrow_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_trash_arrow_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 228}, {50, 57}, opts)
  end
            
  @doc """
  Adds the trash-can-arrow-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/trash-can-arrow-up

  ```
  graph
  |> fontawesome_trash_can_arrow_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_trash_can_arrow_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_trash_can_arrow_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_trash_can_arrow_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 285}, {50, 57}, opts)
  end
            
  @doc """
  Adds the trash-can icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/trash-can

  ```
  graph
  |> fontawesome_trash_can({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_trash_can(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_trash_can(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_trash_can(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 342}, {50, 57}, opts)
  end
            
  @doc """
  Adds the trash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/trash

  ```
  graph
  |> fontawesome_trash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_trash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_trash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_trash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 399}, {50, 57}, opts)
  end
            
  @doc """
  Adds the tree-city icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tree-city

  ```
  graph
  |> fontawesome_tree_city({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tree_city(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tree_city(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tree_city(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the tree icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tree

  ```
  graph
  |> fontawesome_tree({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tree(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tree(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tree(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 456}, {50, 57}, opts)
  end
            
  @doc """
  Adds the triangle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/triangle-exclamation

  ```
  graph
  |> fontawesome_triangle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_triangle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_triangle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_triangle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {400, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the trophy icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/trophy

  ```
  graph
  |> fontawesome_trophy({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_trophy(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_trophy(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_trophy(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the trowel-bricks icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/trowel-bricks

  ```
  graph
  |> fontawesome_trowel_bricks({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_trowel_bricks(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_trowel_bricks(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_trowel_bricks(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {450, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the trowel icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/trowel

  ```
  graph
  |> fontawesome_trowel({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_trowel(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_trowel(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_trowel(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {500, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the truck-arrow-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/truck-arrow-right

  ```
  graph
  |> fontawesome_truck_arrow_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_truck_arrow_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_truck_arrow_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_truck_arrow_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the truck-droplet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/truck-droplet

  ```
  graph
  |> fontawesome_truck_droplet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_truck_droplet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_truck_droplet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_truck_droplet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the truck-fast icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/truck-fast

  ```
  graph
  |> fontawesome_truck_fast({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_truck_fast(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_truck_fast(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_truck_fast(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the truck-field-un icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/truck-field-un

  ```
  graph
  |> fontawesome_truck_field_un({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_truck_field_un(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_truck_field_un(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_truck_field_un(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the truck-field icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/truck-field

  ```
  graph
  |> fontawesome_truck_field({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_truck_field(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_truck_field(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_truck_field(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1800, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the truck-front icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/truck-front

  ```
  graph
  |> fontawesome_truck_front({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_truck_front(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_truck_front(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_truck_front(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {550, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the truck-medical icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/truck-medical

  ```
  graph
  |> fontawesome_truck_medical({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_truck_medical(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_truck_medical(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_truck_medical(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1850, 1829}, {50, 40}, opts)
  end
            
  @doc """
  Adds the truck-monster icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/truck-monster

  ```
  graph
  |> fontawesome_truck_monster({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_truck_monster(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_truck_monster(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_truck_monster(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 0}, {50, 40}, opts)
  end
            
  @doc """
  Adds the truck-moving icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/truck-moving

  ```
  graph
  |> fontawesome_truck_moving({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_truck_moving(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_truck_moving(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_truck_moving(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 40}, {50, 40}, opts)
  end
            
  @doc """
  Adds the truck-pickup icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/truck-pickup

  ```
  graph
  |> fontawesome_truck_pickup({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_truck_pickup(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_truck_pickup(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_truck_pickup(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 80}, {50, 40}, opts)
  end
            
  @doc """
  Adds the truck-plane icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/truck-plane

  ```
  graph
  |> fontawesome_truck_plane({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_truck_plane(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_truck_plane(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_truck_plane(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 120}, {50, 40}, opts)
  end
            
  @doc """
  Adds the truck-ramp-box icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/truck-ramp-box

  ```
  graph
  |> fontawesome_truck_ramp_box({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_truck_ramp_box(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_truck_ramp_box(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_truck_ramp_box(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 160}, {50, 40}, opts)
  end
            
  @doc """
  Adds the truck icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/truck

  ```
  graph
  |> fontawesome_truck({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_truck(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_truck(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_truck(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 200}, {50, 40}, opts)
  end
            
  @doc """
  Adds the tty icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tty

  ```
  graph
  |> fontawesome_tty({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tty(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tty(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tty(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the turkish-lira-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/turkish-lira-sign

  ```
  graph
  |> fontawesome_turkish_lira_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_turkish_lira_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_turkish_lira_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_turkish_lira_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {600, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the turn-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/turn-down

  ```
  graph
  |> fontawesome_turn_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_turn_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_turn_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_turn_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the turn-up icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/turn-up

  ```
  graph
  |> fontawesome_turn_up({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_turn_up(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_turn_up(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_turn_up(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the tv icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/tv

  ```
  graph
  |> fontawesome_tv({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_tv(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_tv(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_tv(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 240}, {50, 40}, opts)
  end
            
  @doc """
  Adds the u icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/u

  ```
  graph
  |> fontawesome_u({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_u(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_u(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_u(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the umbrella-beach icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/umbrella-beach

  ```
  graph
  |> fontawesome_umbrella_beach({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_umbrella_beach(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_umbrella_beach(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_umbrella_beach(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1650, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the umbrella icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/umbrella

  ```
  graph
  |> fontawesome_umbrella({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_umbrella(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_umbrella(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_umbrella(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1700, 1705}, {50, 44}, opts)
  end
            
  @doc """
  Adds the underline icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/underline

  ```
  graph
  |> fontawesome_underline({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_underline(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_underline(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_underline(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 513}, {50, 57}, opts)
  end
            
  @doc """
  Adds the universal-access icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/universal-access

  ```
  graph
  |> fontawesome_universal_access({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_universal_access(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_universal_access(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_universal_access(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {650, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the unlock-keyhole icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/unlock-keyhole

  ```
  graph
  |> fontawesome_unlock_keyhole({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_unlock_keyhole(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_unlock_keyhole(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_unlock_keyhole(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 570}, {50, 57}, opts)
  end
            
  @doc """
  Adds the unlock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/unlock

  ```
  graph
  |> fontawesome_unlock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_unlock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_unlock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_unlock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 627}, {50, 57}, opts)
  end
            
  @doc """
  Adds the up-down-left-right icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/up-down-left-right

  ```
  graph
  |> fontawesome_up_down_left_right({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_up_down_left_right(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_up_down_left_right(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_up_down_left_right(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {700, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the up-down icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/up-down

  ```
  graph
  |> fontawesome_up_down({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_up_down(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_up_down(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_up_down(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 200}, {50, 100}, opts)
  end
            
  @doc """
  Adds the up-long icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/up-long

  ```
  graph
  |> fontawesome_up_long({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_up_long(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_up_long(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_up_long(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 540}, {50, 80}, opts)
  end
            
  @doc """
  Adds the up-right-and-down-left-from-center icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/up-right-and-down-left-from-center

  ```
  graph
  |> fontawesome_up_right_and_down_left_from_center({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_up_right_and_down_left_from_center(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_up_right_and_down_left_from_center(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_up_right_and_down_left_from_center(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {750, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the up-right-from-square icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/up-right-from-square

  ```
  graph
  |> fontawesome_up_right_from_square({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_up_right_from_square(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_up_right_from_square(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_up_right_from_square(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the upload icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/upload

  ```
  graph
  |> fontawesome_upload({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_upload(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_upload(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_upload(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the user-astronaut icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-astronaut

  ```
  graph
  |> fontawesome_user_astronaut({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_astronaut(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_astronaut(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_astronaut(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 684}, {50, 57}, opts)
  end
            
  @doc """
  Adds the user-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-check

  ```
  graph
  |> fontawesome_user_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 280}, {50, 40}, opts)
  end
            
  @doc """
  Adds the user-clock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-clock

  ```
  graph
  |> fontawesome_user_clock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_clock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_clock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_clock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 320}, {50, 40}, opts)
  end
            
  @doc """
  Adds the user-doctor icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-doctor

  ```
  graph
  |> fontawesome_user_doctor({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_doctor(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_doctor(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_doctor(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 741}, {50, 57}, opts)
  end
            
  @doc """
  Adds the user-gear icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-gear

  ```
  graph
  |> fontawesome_user_gear({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_gear(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_gear(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_gear(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 360}, {50, 40}, opts)
  end
            
  @doc """
  Adds the user-graduate icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-graduate

  ```
  graph
  |> fontawesome_user_graduate({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_graduate(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_graduate(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_graduate(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 798}, {50, 57}, opts)
  end
            
  @doc """
  Adds the user-group icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-group

  ```
  graph
  |> fontawesome_user_group({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_group(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_group(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_group(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 400}, {50, 40}, opts)
  end
            
  @doc """
  Adds the user-injured icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-injured

  ```
  graph
  |> fontawesome_user_injured({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_injured(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_injured(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_injured(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 855}, {50, 57}, opts)
  end
            
  @doc """
  Adds the user-large-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-large-slash

  ```
  graph
  |> fontawesome_user_large_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_large_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_large_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_large_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 440}, {50, 40}, opts)
  end
            
  @doc """
  Adds the user-large icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-large

  ```
  graph
  |> fontawesome_user_large({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_large(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_large(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_large(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the user-lock icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-lock

  ```
  graph
  |> fontawesome_user_lock({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_lock(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_lock(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_lock(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 480}, {50, 40}, opts)
  end
            
  @doc """
  Adds the user-minus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-minus

  ```
  graph
  |> fontawesome_user_minus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_minus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_minus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_minus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 520}, {50, 40}, opts)
  end
            
  @doc """
  Adds the user-ninja icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-ninja

  ```
  graph
  |> fontawesome_user_ninja({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_ninja(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_ninja(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_ninja(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 912}, {50, 57}, opts)
  end
            
  @doc """
  Adds the user-nurse icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-nurse

  ```
  graph
  |> fontawesome_user_nurse({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_nurse(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_nurse(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_nurse(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 969}, {50, 57}, opts)
  end
            
  @doc """
  Adds the user-pen icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-pen

  ```
  graph
  |> fontawesome_user_pen({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_pen(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_pen(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_pen(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 560}, {50, 40}, opts)
  end
            
  @doc """
  Adds the user-plus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-plus

  ```
  graph
  |> fontawesome_user_plus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_plus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_plus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_plus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 600}, {50, 40}, opts)
  end
            
  @doc """
  Adds the user-secret icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-secret

  ```
  graph
  |> fontawesome_user_secret({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_secret(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_secret(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_secret(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1026}, {50, 57}, opts)
  end
            
  @doc """
  Adds the user-shield icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-shield

  ```
  graph
  |> fontawesome_user_shield({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_shield(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_shield(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_shield(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 640}, {50, 40}, opts)
  end
            
  @doc """
  Adds the user-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-slash

  ```
  graph
  |> fontawesome_user_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 680}, {50, 40}, opts)
  end
            
  @doc """
  Adds the user-tag icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-tag

  ```
  graph
  |> fontawesome_user_tag({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_tag(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_tag(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_tag(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 720}, {50, 40}, opts)
  end
            
  @doc """
  Adds the user-tie icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-tie

  ```
  graph
  |> fontawesome_user_tie({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_tie(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_tie(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_tie(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {0, 1116}, {50, 57}, opts)
  end
            
  @doc """
  Adds the user-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user-xmark

  ```
  graph
  |> fontawesome_user_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 760}, {50, 40}, opts)
  end
            
  @doc """
  Adds the user icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/user

  ```
  graph
  |> fontawesome_user({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_user(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_user(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_user(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {50, 1116}, {50, 57}, opts)
  end
            
  @doc """
  Adds the users-between-lines icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/users-between-lines

  ```
  graph
  |> fontawesome_users_between_lines({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_users_between_lines(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_users_between_lines(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_users_between_lines(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 800}, {50, 40}, opts)
  end
            
  @doc """
  Adds the users-gear icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/users-gear

  ```
  graph
  |> fontawesome_users_gear({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_users_gear(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_users_gear(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_users_gear(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 840}, {50, 40}, opts)
  end
            
  @doc """
  Adds the users-line icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/users-line

  ```
  graph
  |> fontawesome_users_line({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_users_line(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_users_line(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_users_line(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 880}, {50, 40}, opts)
  end
            
  @doc """
  Adds the users-rays icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/users-rays

  ```
  graph
  |> fontawesome_users_rays({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_users_rays(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_users_rays(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_users_rays(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 920}, {50, 40}, opts)
  end
            
  @doc """
  Adds the users-rectangle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/users-rectangle

  ```
  graph
  |> fontawesome_users_rectangle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_users_rectangle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_users_rectangle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_users_rectangle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 960}, {50, 40}, opts)
  end
            
  @doc """
  Adds the users-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/users-slash

  ```
  graph
  |> fontawesome_users_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_users_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_users_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_users_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1000}, {50, 40}, opts)
  end
            
  @doc """
  Adds the users-viewfinder icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/users-viewfinder

  ```
  graph
  |> fontawesome_users_viewfinder({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_users_viewfinder(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_users_viewfinder(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_users_viewfinder(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1040}, {50, 40}, opts)
  end
            
  @doc """
  Adds the users icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/users

  ```
  graph
  |> fontawesome_users({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_users(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_users(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_users(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1080}, {50, 40}, opts)
  end
            
  @doc """
  Adds the utensils icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/utensils

  ```
  graph
  |> fontawesome_utensils({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_utensils(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_utensils(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_utensils(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {100, 1116}, {50, 57}, opts)
  end
            
  @doc """
  Adds the v icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/v

  ```
  graph
  |> fontawesome_v({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_v(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_v(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_v(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {800, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the van-shuttle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/van-shuttle

  ```
  graph
  |> fontawesome_van_shuttle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_van_shuttle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_van_shuttle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_van_shuttle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1120}, {50, 40}, opts)
  end
            
  @doc """
  Adds the vault icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/vault

  ```
  graph
  |> fontawesome_vault({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_vault(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_vault(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_vault(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 0}, {50, 44}, opts)
  end
            
  @doc """
  Adds the vector-square icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/vector-square

  ```
  graph
  |> fontawesome_vector_square({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_vector_square(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_vector_square(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_vector_square(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {150, 1116}, {50, 57}, opts)
  end
            
  @doc """
  Adds the venus-double icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/venus-double

  ```
  graph
  |> fontawesome_venus_double({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_venus_double(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_venus_double(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_venus_double(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1160}, {50, 40}, opts)
  end
            
  @doc """
  Adds the venus-mars icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/venus-mars

  ```
  graph
  |> fontawesome_venus_mars({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_venus_mars(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_venus_mars(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_venus_mars(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1200}, {50, 40}, opts)
  end
            
  @doc """
  Adds the venus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/venus

  ```
  graph
  |> fontawesome_venus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_venus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_venus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_venus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {850, 821}, {50, 67}, opts)
  end
            
  @doc """
  Adds the vest-patches icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/vest-patches

  ```
  graph
  |> fontawesome_vest_patches({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_vest_patches(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_vest_patches(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_vest_patches(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 1116}, {50, 57}, opts)
  end
            
  @doc """
  Adds the vest icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/vest

  ```
  graph
  |> fontawesome_vest({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_vest(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_vest(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_vest(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 1116}, {50, 57}, opts)
  end
            
  @doc """
  Adds the vial-circle-check icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/vial-circle-check

  ```
  graph
  |> fontawesome_vial_circle_check({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_vial_circle_check(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_vial_circle_check(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_vial_circle_check(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {950, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the vial-virus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/vial-virus

  ```
  graph
  |> fontawesome_vial_virus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_vial_virus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_vial_virus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_vial_virus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1000, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the vial icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/vial

  ```
  graph
  |> fontawesome_vial({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_vial(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_vial(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_vial(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1050, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the vials icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/vials

  ```
  graph
  |> fontawesome_vials({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_vials(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_vials(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_vials(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1100, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the video-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/video-slash

  ```
  graph
  |> fontawesome_video_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_video_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_video_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_video_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1240}, {50, 40}, opts)
  end
            
  @doc """
  Adds the video icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/video

  ```
  graph
  |> fontawesome_video({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_video(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_video(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_video(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 44}, {50, 44}, opts)
  end
            
  @doc """
  Adds the vihara icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/vihara

  ```
  graph
  |> fontawesome_vihara({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_vihara(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_vihara(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_vihara(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1280}, {50, 40}, opts)
  end
            
  @doc """
  Adds the virus-covid-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/virus-covid-slash

  ```
  graph
  |> fontawesome_virus_covid_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_virus_covid_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_virus_covid_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_virus_covid_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1320}, {50, 40}, opts)
  end
            
  @doc """
  Adds the virus-covid icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/virus-covid

  ```
  graph
  |> fontawesome_virus_covid({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_virus_covid(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_virus_covid(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_virus_covid(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1150, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the virus-slash icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/virus-slash

  ```
  graph
  |> fontawesome_virus_slash({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_virus_slash(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_virus_slash(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_virus_slash(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1360}, {50, 40}, opts)
  end
            
  @doc """
  Adds the virus icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/virus

  ```
  graph
  |> fontawesome_virus({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_virus(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_virus(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_virus(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1200, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the viruses icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/viruses

  ```
  graph
  |> fontawesome_viruses({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_viruses(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_viruses(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_viruses(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1400}, {50, 40}, opts)
  end
            
  @doc """
  Adds the voicemail icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/voicemail

  ```
  graph
  |> fontawesome_voicemail({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_voicemail(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_voicemail(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_voicemail(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1440}, {50, 40}, opts)
  end
            
  @doc """
  Adds the volcano icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/volcano

  ```
  graph
  |> fontawesome_volcano({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_volcano(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_volcano(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_volcano(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1250, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the volleyball icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/volleyball

  ```
  graph
  |> fontawesome_volleyball({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_volleyball(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_volleyball(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_volleyball(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1300, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the volume-high icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/volume-high

  ```
  graph
  |> fontawesome_volume_high({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_volume_high(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_volume_high(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_volume_high(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1480}, {50, 40}, opts)
  end
            
  @doc """
  Adds the volume-low icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/volume-low

  ```
  graph
  |> fontawesome_volume_low({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_volume_low(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_volume_low(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_volume_low(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 1116}, {50, 57}, opts)
  end
            
  @doc """
  Adds the volume-off icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/volume-off

  ```
  graph
  |> fontawesome_volume_off({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_volume_off(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_volume_off(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_volume_off(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {200, 540}, {50, 80}, opts)
  end
            
  @doc """
  Adds the volume-xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/volume-xmark

  ```
  graph
  |> fontawesome_volume_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_volume_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_volume_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_volume_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 88}, {50, 44}, opts)
  end
            
  @doc """
  Adds the vr-cardboard icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/vr-cardboard

  ```
  graph
  |> fontawesome_vr_cardboard({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_vr_cardboard(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_vr_cardboard(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_vr_cardboard(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1520}, {50, 40}, opts)
  end
            
  @doc """
  Adds the w icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/w

  ```
  graph
  |> fontawesome_w({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_w(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_w(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_w(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 132}, {50, 44}, opts)
  end
            
  @doc """
  Adds the walkie-talkie icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/walkie-talkie

  ```
  graph
  |> fontawesome_walkie_talkie({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_walkie_talkie(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_walkie_talkie(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_walkie_talkie(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 0}, {50, 67}, opts)
  end
            
  @doc """
  Adds the wallet icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wallet

  ```
  graph
  |> fontawesome_wallet({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wallet(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wallet(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wallet(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1350, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the wand-magic-sparkles icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wand-magic-sparkles

  ```
  graph
  |> fontawesome_wand_magic_sparkles({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wand_magic_sparkles(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wand_magic_sparkles(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wand_magic_sparkles(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 176}, {50, 44}, opts)
  end
            
  @doc """
  Adds the wand-magic icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wand-magic

  ```
  graph
  |> fontawesome_wand_magic({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wand_magic(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wand_magic(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wand_magic(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1400, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the wand-sparkles icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wand-sparkles

  ```
  graph
  |> fontawesome_wand_sparkles({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wand_sparkles(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wand_sparkles(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wand_sparkles(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1450, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the warehouse icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/warehouse

  ```
  graph
  |> fontawesome_warehouse({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_warehouse(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_warehouse(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_warehouse(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1560}, {50, 40}, opts)
  end
            
  @doc """
  Adds the water-ladder icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/water-ladder

  ```
  graph
  |> fontawesome_water_ladder({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_water_ladder(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_water_ladder(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_water_ladder(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 220}, {50, 44}, opts)
  end
            
  @doc """
  Adds the water icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/water

  ```
  graph
  |> fontawesome_water({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_water(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_water(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_water(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1750, 264}, {50, 44}, opts)
  end
            
  @doc """
  Adds the wave-square icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wave-square

  ```
  graph
  |> fontawesome_wave_square({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wave_square(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wave_square(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wave_square(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1600}, {50, 40}, opts)
  end
            
  @doc """
  Adds the web-awesome icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/web-awesome

  ```
  graph
  |> fontawesome_web_awesome({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_web_awesome(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_web_awesome(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_web_awesome(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1640}, {50, 40}, opts)
  end
            
  @doc """
  Adds the weight-hanging icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/weight-hanging

  ```
  graph
  |> fontawesome_weight_hanging({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_weight_hanging(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_weight_hanging(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_weight_hanging(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1500, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the weight-scale icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/weight-scale

  ```
  graph
  |> fontawesome_weight_scale({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_weight_scale(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_weight_scale(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_weight_scale(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1550, 1523}, {50, 50}, opts)
  end
            
  @doc """
  Adds the wheat-awn-circle-exclamation icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wheat-awn-circle-exclamation

  ```
  graph
  |> fontawesome_wheat_awn_circle_exclamation({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wheat_awn_circle_exclamation(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wheat_awn_circle_exclamation(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wheat_awn_circle_exclamation(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1680}, {50, 40}, opts)
  end
            
  @doc """
  Adds the wheat-awn icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wheat-awn

  ```
  graph
  |> fontawesome_wheat_awn({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wheat_awn(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wheat_awn(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wheat_awn(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 0}, {50, 50}, opts)
  end
            
  @doc """
  Adds the wheelchair-move icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wheelchair-move

  ```
  graph
  |> fontawesome_wheelchair_move({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wheelchair_move(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wheelchair_move(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wheelchair_move(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 1116}, {50, 57}, opts)
  end
            
  @doc """
  Adds the wheelchair icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wheelchair

  ```
  graph
  |> fontawesome_wheelchair({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wheelchair(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wheelchair(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wheelchair(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 50}, {50, 50}, opts)
  end
            
  @doc """
  Adds the whiskey-glass icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/whiskey-glass

  ```
  graph
  |> fontawesome_whiskey_glass({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_whiskey_glass(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_whiskey_glass(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_whiskey_glass(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 100}, {50, 50}, opts)
  end
            
  @doc """
  Adds the wifi icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wifi

  ```
  graph
  |> fontawesome_wifi({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wifi(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wifi(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wifi(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1720}, {50, 40}, opts)
  end
            
  @doc """
  Adds the wind icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wind

  ```
  graph
  |> fontawesome_wind({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wind(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wind(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wind(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 150}, {50, 50}, opts)
  end
            
  @doc """
  Adds the window-maximize icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/window-maximize

  ```
  graph
  |> fontawesome_window_maximize({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_window_maximize(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_window_maximize(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_window_maximize(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 200}, {50, 50}, opts)
  end
            
  @doc """
  Adds the window-minimize icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/window-minimize

  ```
  graph
  |> fontawesome_window_minimize({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_window_minimize(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_window_minimize(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_window_minimize(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 250}, {50, 50}, opts)
  end
            
  @doc """
  Adds the window-restore icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/window-restore

  ```
  graph
  |> fontawesome_window_restore({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_window_restore(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_window_restore(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_window_restore(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 300}, {50, 50}, opts)
  end
            
  @doc """
  Adds the wine-bottle icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wine-bottle

  ```
  graph
  |> fontawesome_wine_bottle({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wine_bottle(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wine_bottle(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wine_bottle(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 350}, {50, 50}, opts)
  end
            
  @doc """
  Adds the wine-glass-empty icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wine-glass-empty

  ```
  graph
  |> fontawesome_wine_glass_empty({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wine_glass_empty(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wine_glass_empty(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wine_glass_empty(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {250, 540}, {50, 80}, opts)
  end
            
  @doc """
  Adds the wine-glass icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wine-glass

  ```
  graph
  |> fontawesome_wine_glass({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wine_glass(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wine_glass(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wine_glass(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {300, 540}, {50, 80}, opts)
  end
            
  @doc """
  Adds the won-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/won-sign

  ```
  graph
  |> fontawesome_won_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_won_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_won_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_won_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 400}, {50, 50}, opts)
  end
            
  @doc """
  Adds the worm icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/worm

  ```
  graph
  |> fontawesome_worm({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_worm(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_worm(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_worm(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 450}, {50, 50}, opts)
  end
            
  @doc """
  Adds the wrench icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/wrench

  ```
  graph
  |> fontawesome_wrench({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_wrench(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_wrench(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_wrench(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 500}, {50, 50}, opts)
  end
            
  @doc """
  Adds the x-ray icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/x-ray

  ```
  graph
  |> fontawesome_x_ray({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_x_ray(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_x_ray(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_x_ray(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 550}, {50, 50}, opts)
  end
            
  @doc """
  Adds the x icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/x

  ```
  graph
  |> fontawesome_x({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_x(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_x(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_x(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 67}, {50, 67}, opts)
  end
            
  @doc """
  Adds the xmark icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/xmark

  ```
  graph
  |> fontawesome_xmark({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_xmark(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_xmark(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_xmark(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 134}, {50, 67}, opts)
  end
            
  @doc """
  Adds the xmarks-lines icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/xmarks-lines

  ```
  graph
  |> fontawesome_xmarks_lines({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_xmarks_lines(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_xmarks_lines(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_xmarks_lines(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1900, 1760}, {50, 40}, opts)
  end
            
  @doc """
  Adds the y icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/y

  ```
  graph
  |> fontawesome_y({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_y(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_y(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_y(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 201}, {50, 67}, opts)
  end
            
  @doc """
  Adds the yen-sign icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/yen-sign

  ```
  graph
  |> fontawesome_yen_sign({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_yen_sign(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_yen_sign(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_yen_sign(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {350, 540}, {50, 80}, opts)
  end
            
  @doc """
  Adds the yin-yang icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/yin-yang

  ```
  graph
  |> fontawesome_yin_yang({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_yin_yang(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_yin_yang(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_yin_yang(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {1600, 600}, {50, 50}, opts)
  end
            
  @doc """
  Adds the z icon to the graph at the specified coordinations, see: https://fontawesome.com/icons/z

  ```
  graph
  |> fontawesome_z({10,20}, fill: :dark)
  ```
  """
  @spec fontawesome_z(
          source :: Graph.t() | Primitive.t(),
          {number(), number()},
          options :: list()
          ) :: Graph.t() | Primitive.t()

  def fontawesome_z(graph_or_primitive, destination_coordinates, opts \\ [])

  def fontawesome_z(graph_or_primitive, {dest_x, dest_y}, opts) do
      {fill, opts} = Keyword.pop(opts, :fill)

      graph_or_primitive
      |> Icon.render(spritesheet(fill), {dest_x, dest_y}, {900, 268}, {50, 67}, opts)
  end
            
end