code: def crt(m, v, symmetric=False, check=True):
      r"""Chinese Remainder Theorem.
  
      The moduli in m are assumed to be pairwise coprime.  The output
      is then an integer f, such that f = v_i mod m_i for each pair out
      of v and m. If ``symmetric`` is False a positive integer will be
      returned, else \|f\| will be less than or equal to the LCM of the
      moduli, and thus f may be negative.
  
      If the moduli are not co-prime the correct result will be returned
      if/when the test of the result is found to be incorrect. This result
      will be None if there is no solution.
  
      The keyword ``check`` can be set to False if it is known that the moduli
      are coprime.
  
      Examples
      ========
  
      As an example consider a set of residues ``U = [49, 76, 65]``
      and a set of moduli ``M = [99, 97, 95]``. Then we have::
  
         >>> from sympy.ntheory.modular import crt
  
         >>> crt([99, 97, 95], [49, 76, 65])
         (639985, 912285)
  
      This is the correct result because::
  
         >>> [639985 % m for m in [99, 97, 95]]
         [49, 76, 65]
  
      If the moduli are not co-prime, you may receive an incorrect result
      if you use ``check=False``:
  
         >>> crt([12, 6, 17], [3, 4, 2], check=False)
         (954, 1224)
         >>> [954 % m for m in [12, 6, 17]]
         [6, 0, 2]
         >>> crt([12, 6, 17], [3, 4, 2]) is None
         True
         >>> crt([3, 6], [2, 5])
         (5, 6)
  
      Note: the order of gf_crt's arguments is reversed relative to crt,
      and that solve_congruence takes residue, modulus pairs.
  
      Programmer's note: rather than checking that all pairs of moduli share
      no GCD (an O(n**2) test) and rather than factoring all moduli and seeing
      that there is no factor in common, a check that the result gives the
      indicated residuals is performed -- an O(n) operation.
  
      See Also
      ========
  
      solve_congruence
      sympy.polys.galoistools.gf_crt : low level crt routine used by this routine
      """
      if check:
          m = list(map(as_int, m))
          v = list(map(as_int, v))
  
      result = gf_crt(v, m, ZZ)
      mm = prod(m)
  
      if check:
          if not all(v % m == result % m for v, m in zip(v, m)):
              result = solve_congruence(
                  *list(zip(v, m)), check=False, symmetric=symmetric
              )
              if result is None:
                  return result
              result, mm = result
  
      if symmetric:
          return int(symmetric_residue(result, mm)), int(mm)
      return int(result), int(mm)
  
file_path: sympy/sympy/ntheory/modular.py
imports: from math import prod
  from sympy.external.gmpy import gcd, gcdext
  from sympy.ntheory.primetest import isprime
  from sympy.polys.domains import ZZ
  from sympy.polys.galoistools import gf_crt, gf_crt1, gf_crt2
  from sympy.utilities.misc import as_int
label_desc: Use image node_id 2 for calling a global function with example usage: crt(m, v, symmetric, check) and returns: int,  int, int,  int, result