code: def fibonacci_function_calls(include_types=True, dtype=np.int64):
      """The Fibonacci program again, but with `instructions.FunctionCallOp`.
  
      Computes fib(n): fib(0) = fib(1) = 1.
  
      Args:
        include_types: If False, we omit types on the variables, requiring a type
            inference pass.
        dtype: The dtype to use for `n`-like internal state variables.
  
      Returns:
        program: Full-powered `instructions.Program` that computes fib(n).
      """
      enter_fib = instructions.Block(name="enter_fib")
      recur = instructions.Block(name="recur")
      finish = instructions.Block(name="finish")
  
      fibonacci_type = lambda types: types[0]
      fibonacci_func = instructions.Function(
          None, ["n"], "ans", fibonacci_type, name="fibonacci"
      )
      # pylint: disable=bad-whitespace
      # Definition of fibonacci function
      enter_fib.assign_instructions(
          [
              instructions.prim_op(
                  ["n"], "cond", lambda n: n > 1
              ),  # cond = n > 1
              instructions.BranchOp("cond", recur, finish),  # if cond
          ]
      )
      recur.assign_instructions(
          [
              instructions.prim_op(
                  ["n"], "nm1", lambda n: n - 1
              ),  #   nm1 = n - 1
              instructions.FunctionCallOp(
                  fibonacci_func, ["nm1"], "fibm1"
              ),  #   fibm1 = fibonacci(nm1)
              instructions.prim_op(
                  ["n"], "nm2", lambda n: n - 2
              ),  #   nm2 = n - 2
              instructions.FunctionCallOp(
                  fibonacci_func, ["nm2"], "fibm2"
              ),  #   fibm2 = fibonacci(nm2)
              instructions.prim_op(
                  ["fibm1", "fibm2"], "ans", lambda x, y: x + y
              ),  #   ans = fibm1 + fibm2
              instructions.halt_op(),  #   return ans
          ]
      )
      finish.assign_instructions(
          [  # else:
              instructions.prim_op([], "ans", lambda: 1),  #   ans = 1
              instructions.halt_op(),  #   return ans
          ]
      )
      fibonacci_blocks = [enter_fib, recur, finish]
      fibonacci_func.graph = instructions.ControlFlowGraph(
          fibonacci_blocks
      )
  
      fibonacci_main_blocks = [
          instructions.Block(
              [
                  instructions.FunctionCallOp(
                      fibonacci_func, ["n1"], "ans"
                  ),
              ],
              instructions.halt_op(),
              name="main_entry",
          ),
      ]
  
      # pylint: disable=bad-whitespace
      fibonacci_vars = {
          "n": instructions.single_type(dtype, ()),
          "n1": instructions.single_type(dtype, ()),
          "cond": instructions.single_type(np.bool_, ()),
          "nm1": instructions.single_type(dtype, ()),
          "fibm1": instructions.single_type(dtype, ()),
          "nm2": instructions.single_type(dtype, ()),
          "fibm2": instructions.single_type(dtype, ()),
          "ans": instructions.single_type(dtype, ()),
      }
      if not include_types:
          _strip_types(fibonacci_vars)
  
      return instructions.Program(
          instructions.ControlFlowGraph(fibonacci_main_blocks),
          [fibonacci_func],
          fibonacci_vars,
          ["n1"],
          "ans",
      )
  
file_path: probability/tensorflow_probability/python/experimental/auto_batching/test_programs.py
imports: import numpy
  from tensorflow_probability.python.experimental.auto_batching import instructions
label_desc: Use image node_id 8 for calling a global function with example usage: fibonacci_function_calls(include_types, dtype) and returns: instructions