code: # Squarified Treemap Layout
  # Implements algorithm from Bruls, Huizing, van Wijk, "Squarified Treemaps" and Laserson with some modifications
  #   (but not using their pseudocode)
  
  
  # INTERNAL FUNCTIONS not meant to be used by the user
  
  
  def pad_rectangle(rect):
      if rect["dx"] > 2:
          rect["x"] += 1
          rect["dx"] -= 2
      if rect["dy"] > 2:
          rect["y"] += 1
          rect["dy"] -= 2
  
  
  def layoutrow(sizes, x, y, dx, dy):
      # generate rects for each size in sizes
      # dx >= dy
      # they will fill up height dy, and width will be determined by their area
      # sizes should be pre-normalized wrt dx * dy (i.e., they should be same units)
      covered_area = sum(sizes)
      width = covered_area / dy
      rects = []
      for size in sizes:
          rects.append({"x": x, "y": y, "dx": width, "dy": size / width})
          y += size / width
      return rects
  
  
  def layoutcol(sizes, x, y, dx, dy):
      # generate rects for each size in sizes
      # dx < dy
      # they will fill up width dx, and height will be determined by their area
      # sizes should be pre-normalized wrt dx * dy (i.e., they should be same units)
      covered_area = sum(sizes)
      height = covered_area / dx
      rects = []
      for size in sizes:
          rects.append({"x": x, "y": y, "dx": size / height, "dy": height})
          x += size / height
      return rects
  
  
  def layout(sizes, x, y, dx, dy):
      return (
          layoutrow(sizes, x, y, dx, dy) if dx >= dy else layoutcol(sizes, x, y, dx, dy)
      )
  
  
  def leftoverrow(sizes, x, y, dx, dy):
      # compute remaining area when dx >= dy
      covered_area = sum(sizes)
      width = covered_area / dy
      leftover_x = x + width
      leftover_y = y
      leftover_dx = dx - width
      leftover_dy = dy
      return (leftover_x, leftover_y, leftover_dx, leftover_dy)
  
  
  def leftovercol(sizes, x, y, dx, dy):
      # compute remaining area when dx >= dy
      covered_area = sum(sizes)
      height = covered_area / dx
      leftover_x = x
      leftover_y = y + height
      leftover_dx = dx
      leftover_dy = dy - height
      return (leftover_x, leftover_y, leftover_dx, leftover_dy)
  
  
  def leftover(sizes, x, y, dx, dy):
      return (
          leftoverrow(sizes, x, y, dx, dy)
          if dx >= dy
          else leftovercol(sizes, x, y, dx, dy)
      )
  
  
  def worst_ratio(sizes, x, y, dx, dy):
      return max(
          [
              max(rect["dx"] / rect["dy"], rect["dy"] / rect["dx"])
              for rect in layout(sizes, x, y, dx, dy)
          ]
      )
  
  
  # PUBLIC API
  
  
  def squarify(sizes, x, y, dx, dy):
      """Compute treemap rectangles.
      Given a set of values, computes a treemap layout in the specified geometry
      using an algorithm based on Bruls, Huizing, van Wijk, "Squarified Treemaps".
      See README for example usage.
      Parameters
      ----------
      sizes : list-like of numeric values
          The set of values to compute a treemap for. `sizes` must be positive
          values sorted in descending order and they should be normalized to the
          total area (i.e., `dx * dy == sum(sizes)`)
      x, y : numeric
          The coordinates of the "origin".
      dx, dy : numeric
          The full width (`dx`) and height (`dy`) of the treemap.
      Returns
      -------
      list[dict]
          Each dict in the returned list represents a single rectangle in the
          treemap. The order corresponds to the input order.
      """
      sizes = list(map(float, sizes))
  
      if len(sizes) == 0:
          return []
  
      if len(sizes) == 1:
          return layout(sizes, x, y, dx, dy)
  
      # figure out where 'split' should be
      i = 1
      while i < len(sizes) and worst_ratio(sizes[:i], x, y, dx, dy) >= worst_ratio(
          sizes[: (i + 1)], x, y, dx, dy
      ):
          i += 1
      current = sizes[:i]
      remaining = sizes[i:]
  
      (leftover_x, leftover_y, leftover_dx, leftover_dy) = leftover(current, x, y, dx, dy)
      return layout(current, x, y, dx, dy) + squarify(
          remaining, leftover_x, leftover_y, leftover_dx, leftover_dy
      )
  
  
  def padded_squarify(sizes, x, y, dx, dy):
      """Compute padded treemap rectangles.
      See `squarify` docstring for details. The only difference is that the
      returned rectangles have been "padded" to allow for a visible border.
      """
      rects = squarify(sizes, x, y, dx, dy)
      for rect in rects:
          pad_rectangle(rect)
      return rects
  
  
  def normalize_sizes(sizes, dx, dy):
      """Normalize list of values.
      Normalizes a list of numeric values so that `sum(sizes) == dx * dy`.
      Parameters
      ----------
      sizes : list-like of numeric values
          Input list of numeric values to normalize.
      dx, dy : numeric
          The dimensions of the full rectangle to normalize total values to.
      Returns
      -------
      list[numeric]
          The normalized values.
      """
      total_size = sum(sizes)
      total_area = dx * dy
      sizes = map(float, sizes)
      sizes = map(lambda size: size * total_area / total_size, sizes)
      return list(sizes)
  
  
  def plot(
      sizes,
      norm_x=100,
      norm_y=100,
      color=None,
      label=None,
      value=None,
      ax=None,
      pad=False,
      bar_kwargs=None,
      text_kwargs=None,
      **kwargs
  ):
      """Plotting with Matplotlib.
      Parameters
      ----------
      sizes
          input for squarify
      norm_x, norm_y
          x and y values for normalization
      color
          color string or list-like (see Matplotlib documentation for details)
      label
          list-like used as label text
      value
          list-like used as value text (in most cases identical with sizes argument)
      ax
          Matplotlib Axes instance
      pad
          draw rectangles with a small gap between them
      bar_kwargs : dict
          keyword arguments passed to matplotlib.Axes.bar
      text_kwargs : dict
          keyword arguments passed to matplotlib.Axes.text
      **kwargs
          Any additional kwargs are merged into `bar_kwargs`. Explicitly provided
          kwargs here will take precedence.
      Returns
      -------
      matplotlib.axes.Axes
          Matplotlib Axes
      """
  
      import matplotlib.pyplot as plt
      from math import ceil
  
      if ax is None:
          ax = plt.gca()
  
      if color is None:
          color_cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']
          if len(sizes) > len(color_cycle):
              color_cycle = color_cycle * ceil(len(color_cycle)/len(sizes))
          color = color_cycle[:len(sizes)]
  
      if bar_kwargs is None:
          bar_kwargs = {}
      if text_kwargs is None:
          text_kwargs = {}
      if len(kwargs) > 0:
          bar_kwargs.update(kwargs)
  
      normed = normalize_sizes(sizes, norm_x, norm_y)
  
      if pad:
          rects = padded_squarify(normed, 0, 0, norm_x, norm_y)
      else:
          rects = squarify(normed, 0, 0, norm_x, norm_y)
  
      x = [rect["x"] for rect in rects]
      y = [rect["y"] for rect in rects]
      dx = [rect["dx"] for rect in rects]
      dy = [rect["dy"] for rect in rects]
  
      ax.bar(
          x, dy, width=dx, bottom=y, color=color, label=label, align="edge", **bar_kwargs
      )
  
      if value is not None:
          va = "center" if label is None else "top"
  
          for v, r in zip(value, rects):
              x, y, dx, dy = r["x"], r["y"], r["dx"], r["dy"]
              ax.text(x + dx / 2, y + dy / 2, v, va=va, ha="center", **text_kwargs)
  
      if label is not None:
          va = "center" if value is None else "bottom"
          for l, r in zip(label, rects):
              x, y, dx, dy = r["x"], r["y"], r["dx"], r["dy"]
              ax.text(x + dx / 2, y + dy / 2, l, va=va, ha="center", **text_kwargs)
  
      ax.set_xlim(0, norm_x)
      ax.set_ylim(0, norm_y)
      ax.axis('off')
  
      return ax
apis: matplotlib.pyplot.gca