code: def plot_partition(figures_dir, gnmax_conf, print_order):
      """Plots an expert version of the privacy-per-answered-query graph.
  
      Args:
        figures_dir: A name of the directory where to save the plot.
        eps: The cumulative privacy cost.
        partition: Allocation of the privacy cost.
        answered: Cumulative number of queries answered.
        order_opt: The list of optimal orders.
      """
      eps_partitioned, answered, ss_std_opt, order_opt = gnmax_conf
  
      xlim = 10000
      x = range(0, int(xlim), 10)
      lenx = len(x)
      y0 = np.full(lenx, np.nan, dtype=float)  # delta
      y1 = np.full(lenx, np.nan, dtype=float)  # delta + step1
      y2 = np.full(lenx, np.nan, dtype=float)  # delta + step1 + step2
      y3 = np.full(
          lenx, np.nan, dtype=float
      )  # delta + step1 + step2 + ss
      noise_std = np.full(lenx, np.nan, dtype=float)
  
      y_right = np.full(lenx, np.nan, dtype=float)
  
      for i in range(lenx):
          idx = np.searchsorted(answered, x[i])
          if idx < len(eps_partitioned):
              y0[i] = eps_partitioned[idx].delta
              y1[i] = y0[i] + eps_partitioned[idx].step1
              y2[i] = y1[i] + eps_partitioned[idx].step2
              y3[i] = y2[i] + eps_partitioned[idx].ss
  
              noise_std[i] = ss_std_opt[idx]
              y_right[i] = order_opt[idx]
  
      # plt.close('all')
      fig, ax = plt.subplots()
      fig.set_figheight(4.5)
      fig.set_figwidth(4.7)
      fig.patch.set_alpha(0)
  
      l1 = ax.plot(
          x,
          y3,
          color="b",
          ls="-",
          label=r"Total privacy cost",
          linewidth=1,
      ).pop()
  
      for y in (y0, y1, y2):
          ax.plot(
              x,
              y,
              color="b",
              ls="-",
              label=r"_nolegend_",
              alpha=0.5,
              linewidth=1,
          )
  
      ax.fill_between(
          x, [0] * lenx, y0.tolist(), facecolor="b", alpha=0.5
      )
      ax.fill_between(
          x, y0.tolist(), y1.tolist(), facecolor="b", alpha=0.4
      )
      ax.fill_between(
          x, y1.tolist(), y2.tolist(), facecolor="b", alpha=0.3
      )
      ax.fill_between(
          x, y2.tolist(), y3.tolist(), facecolor="b", alpha=0.2
      )
  
      ax.fill_between(
          x,
          (y3 - noise_std).tolist(),
          (y3 + noise_std).tolist(),
          facecolor="r",
          alpha=0.5,
      )
  
      plt.xticks(np.arange(0, xlim + 1000, 2000))
      plt.xlim([0, xlim])
      ax.set_ylim([0, 3.0])
  
      ax.set_xlabel("Number of queries answered", fontsize=16)
      ax.set_ylabel(
          r"Privacy cost $\varepsilon$ at $\delta=10^{-8}$", fontsize=16
      )
  
      # Merging legends.
      if print_order:
          ax2 = ax.twinx()
          l2 = ax2.plot(
              x,
              y_right,
              "r",
              ls="-",
              label=r"Optimal order",
              linewidth=5,
              alpha=0.5,
          ).pop()
          ax2.grid(False)
          # ax2.set_ylabel(r'Optimal Renyi order', fontsize=16)
          ax2.set_ylim([0, 200.0])
          # ax.legend((l1, l2), (l1.get_label(), l2.get_label()), loc=0, fontsize=13)
  
      ax.tick_params(labelsize=14)
      plot_filename = os.path.join(figures_dir, "partition.pdf")
      print("Saving the graph to " + plot_filename)
      fig.savefig(plot_filename, bbox_inches="tight", dpi=800)
      plt.show()
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import math
  import os
  import pickle
  import sys
  from absl import app
  from absl import flags
  from collections import namedtuple
  import matplotlib
  import matplotlib.pyplot
  import numpy
  import core
  import smooth_sensitivity
label_desc: Use image node_id 4 for calling a global function with example usage: plot_partition(figures_dir, gnmax_conf, print_order) without return types