docs: def sgc_game(k):
      """
      Return a NormalFormGame instance of the 2-player game introduced by
      Sandholm, Gilpin, and Conitzer (2005), which has a unique Nash
      equilibrium, where each player plays half of the actions with
      positive probabilities. Payoffs are normalized so that the minimum
      and the maximum payoffs are 0 and 1, respectively.
  
      Parameters
      ----------
      k : scalar(int)
          Positive integer determining the number of actions. The returned
          game will have `4*k-1` actions for each player.
  
      Returns
      -------
      g : NormalFormGame
  
      Examples
      --------
      >>> g = sgc_game(2)
      >>> g.players[0]
      Player([[ 0.75,  0.5 ,  1.  ,  0.5 ,  0.5 ,  0.5 ,  0.5 ],
              [ 1.  ,  0.75,  0.5 ,  0.5 ,  0.5 ,  0.5 ,  0.5 ],
              [ 0.5 ,  1.  ,  0.75,  0.5 ,  0.5 ,  0.5 ,  0.5 ],
              [ 0.  ,  0.  ,  0.  ,  0.75,  0.  ,  0.  ,  0.  ],
              [ 0.  ,  0.  ,  0.  ,  0.  ,  0.75,  0.  ,  0.  ],
              [ 0.  ,  0.  ,  0.  ,  0.  ,  0.  ,  0.75,  0.  ],
              [ 0.  ,  0.  ,  0.  ,  0.  ,  0.  ,  0.  ,  0.75]])
      >>> g.players[1]
      Player([[ 0.75,  0.5 ,  1.  ,  0.5 ,  0.5 ,  0.5 ,  0.5 ],
              [ 1.  ,  0.75,  0.5 ,  0.5 ,  0.5 ,  0.5 ,  0.5 ],
              [ 0.5 ,  1.  ,  0.75,  0.5 ,  0.5 ,  0.5 ,  0.5 ],
              [ 0.  ,  0.  ,  0.  ,  0.  ,  0.75,  0.  ,  0.  ],
              [ 0.  ,  0.  ,  0.  ,  0.75,  0.  ,  0.  ,  0.  ],
              [ 0.  ,  0.  ,  0.  ,  0.  ,  0.  ,  0.  ,  0.75],
              [ 0.  ,  0.  ,  0.  ,  0.  ,  0.  ,  0.75,  0.  ]])
  
      """
      payoff_arrays = tuple(np.empty((4*k-1, 4*k-1)) for i in range(2))
      _populate_sgc_payoff_arrays(payoff_arrays)
      g = NormalFormGame(
          [Player(payoff_array) for payoff_array in payoff_arrays]
      )
      return g