code: def gamma_taylor_coefficients(inprec):
      """
      Gives the Taylor coefficients of 1/gamma(1+x) as
      a list of fixed-point numbers. Enough coefficients are returned
      to ensure that the series converges to the given precision
      when x is in [0.5, 1.5].
      """
      # Reuse nearby cache values (small case)
      if inprec < 400:
          prec = inprec + (10 - (inprec % 10))
      elif inprec < 1000:
          prec = inprec + (30 - (inprec % 30))
      else:
          prec = inprec
      if prec in gamma_taylor_cache:
          return gamma_taylor_cache[prec], prec
  
      # Experimentally determined bounds
      if prec < 1000:
          N = int(prec**0.76 + 2)
      else:
          # Valid to at least 15000 bits
          N = int(prec**0.787 + 2)
  
      # Reuse higher precision values
      for cprec in gamma_taylor_cache:
          if cprec > prec:
              coeffs = [
                  x >> (cprec - prec)
                  for x in gamma_taylor_cache[cprec][-N:]
              ]
              if inprec < 1000:
                  gamma_taylor_cache[prec] = coeffs
              return coeffs, prec
  
      # Cache at a higher precision (large case)
      if prec > 1000:
          prec = int(prec * 1.2)
  
      wp = prec + 20
      A = [0] * N
      A[0] = MPZ_ZERO
      A[1] = MPZ_ONE << wp
      A[2] = euler_fixed(wp)
      # SLOW, reference implementation
      # zeta_values = [0,0]+[to_fixed(mpf_zeta_int(k,wp),wp) for k in xrange(2,N)]
      zeta_values = zeta_array(N, wp)
      for k in xrange(3, N):
          a = (-A[2] * A[k - 1]) >> wp
          for j in xrange(2, k):
              a += ((-1) ** j * zeta_values[j] * A[k - j]) >> wp
          a //= 1 - k
          A[k] = a
      A = [a >> 20 for a in A]
      A = A[::-1]
      A = A[:-1]
      gamma_taylor_cache[prec] = A
      # return A, prec
      return gamma_taylor_coefficients(inprec)
  
imports: import math
  import sys
  from .backend import xrange
  from .backend import MPZ, MPZ_ZERO, MPZ_ONE, MPZ_THREE, gmpy
  from .libintmath import list_primes, ifac, ifac2, moebius
  from .libmpf import round_floor, round_ceiling, round_down, round_up, round_nearest, round_fast, lshift, sqrt_fixed, isqrt_fast, fzero, fone, fnone, fhalf, ftwo, finf, fninf, fnan, from_int, to_int, to_fixed, from_man_exp, from_rational, mpf_pos, mpf_neg, mpf_abs, mpf_add, mpf_sub, mpf_mul, mpf_mul_int, mpf_div, mpf_sqrt, mpf_pow_int, mpf_rdiv_int, mpf_perturb, mpf_le, mpf_lt, mpf_gt, mpf_shift, negative_rnd, reciprocal_rnd, bitcount, to_float, mpf_floor, mpf_sign, ComplexResult
  from .libelefun import constant_memo, def_mpf_constant, mpf_pi, pi_fixed, ln2_fixed, log_int_fixed, mpf_ln2, mpf_exp, mpf_log, mpf_pow, mpf_cosh, mpf_cos_sin, mpf_cosh_sinh, mpf_cos_sin_pi, mpf_cos_pi, mpf_sin_pi, ln_sqrt2pi_fixed, mpf_ln_sqrt2pi, sqrtpi_fixed, mpf_sqrtpi, cos_sin_fixed, exp_fixed
  from .libmpc import mpc_zero, mpc_one, mpc_half, mpc_two, mpc_abs, mpc_shift, mpc_pos, mpc_neg, mpc_add, mpc_sub, mpc_mul, mpc_div, mpc_add_mpf, mpc_mul_mpf, mpc_div_mpf, mpc_mpf_div, mpc_mul_int, mpc_pow_int, mpc_log, mpc_exp, mpc_pow, mpc_cos_pi, mpc_sin_pi, mpc_reciprocal, mpc_square, mpc_sub_mpf
label_desc: Use image node_id 29 for calling a global function with example usage: gamma_taylor_coefficients(inprec) and returns: gamma_taylor_coefficients, gamma_taylor_cache,  prec, coeffs,  prec