code: def main(extended=True, verbose=True):
      target_set = []
  
      stats = tools.Statistics(lambda ind: ind.fitness.values)
      stats.register("avg", numpy.mean)
      stats.register("std", numpy.std)
      stats.register("min", numpy.min)
      stats.register("max", numpy.max)
  
      logbook = tools.Logbook()
      logbook.header = (
          "gen",
          "species",
          "evals",
          "std",
          "min",
          "avg",
          "max",
      )
  
      ngen = 150
      g = 0
  
      for i in range(len(schematas)):
          size = int(TARGET_SIZE / len(schematas))
          target_set.extend(toolbox.target_set(schematas[i], size))
  
      species = [toolbox.species() for _ in range(NUM_SPECIES)]
  
      # Init with random a representative for each species
      representatives = [random.choice(s) for s in species]
  
      if plt and extended:
          # We must save the match strength to plot them
          t1, t2, t3 = list(), list(), list()
  
      while g < ngen:
          # Initialize a container for the next generation representatives
          next_repr = [None] * len(species)
          for i, s in enumerate(species):
              # Vary the species individuals
              s = algorithms.varAnd(s, toolbox, 0.6, 1.0)
  
              # Get the representatives excluding the current species
              r = representatives[:i] + representatives[i + 1 :]
              for ind in s:
                  ind.fitness.values = toolbox.evaluate(
                      [ind] + r, target_set
                  )
  
              record = stats.compile(s)
              logbook.record(gen=g, species=i, evals=len(s), **record)
  
              if verbose:
                  print(logbook.stream)
  
              # Select the individuals
              species[i] = toolbox.select(
                  s, len(s)
              )  # Tournament selection
              next_repr[i] = toolbox.get_best(s)[0]  # Best selection
  
              g += 1
  
              if plt and extended:
                  # Compute the match strength without noise for the
                  # representatives on the three schematas
                  t1.append(
                      toolbox.evaluate_nonoise(
                          representatives,
                          toolbox.target_set(schematas[0], 1),
                          noise,
                      )[0]
                  )
                  t2.append(
                      toolbox.evaluate_nonoise(
                          representatives,
                          toolbox.target_set(schematas[1], 1),
                          noise,
                      )[0]
                  )
                  t3.append(
                      toolbox.evaluate_nonoise(
                          representatives,
                          toolbox.target_set(schematas[2], 1),
                          noise,
                      )[0]
                  )
  
          representatives = next_repr
      if extended:
          for r in representatives:
              # print individuals without noise
              print(
                  "".join(str(x) for x, y in zip(r, noise) if y == "*")
              )
  
      if plt and extended:
          # Do the final plotting
          plt.plot(t1, "-", color="k", label="Target 1")
          plt.plot(t2, "--", color="k", label="Target 2")
          plt.plot(t3, ":", color="k", label="Target 3")
          plt.legend(loc="lower right")
          plt.axis([0, ngen, 0, max(max(t1), max(t2), max(t3)) + 1])
          plt.xlabel("Generations")
          plt.ylabel("Number of matched bits")
          plt.show()
  
imports: import random
  import numpy
  from deap import algorithms
  from deap import tools
  import coop_base
label_desc: Use image node_id 1 for calling a global function with example usage: main(extended, verbose) without return types