private val ASCII = Charsets.US_ASCII

  fun encodeQuery(
    host: String,
    type: Int,
  ): ByteString =
    Buffer().apply {
      writeShort(0) // query id
      writeShort(256) // flags with recursion
      writeShort(1) // question count
      writeShort(0) // answerCount
      writeShort(0) // authorityResourceCount
      writeShort(0) // additional

      val nameBuf = Buffer()

						t, a, prev)
				}
				if t.Kind() != reflect.Ptr {
					return fmt.Errorf("%s: fact type %s is not a pointer", a, t)
				}
				factTypes[t] = a
			}

			// recursion
			for _, req := range a.Requires {
				if err := visit(req); err != nil {
					return err
				}
			}
			color[a] = black
		}

		if color[a] == grey {
			stack := []*Analyzer{a}

            { it.group },
            { it.isPublic() },
            [{ it.projectIdentifier }, { a, e -> checkProjectIdentifier(a, e) }],
            { it.project.path }, // only check path to avoid infinite recursion
        ])
    }

    static void checkGradleProject(actual, expected) {
        assert expected instanceof GradleProject
        assert actual instanceof GradleProject

namespace {

// Check that there is no recursion in the module's call graph.
LogicalResult CheckNoRecursion(ModuleOp module, CallGraph &call_graph) {
  for (llvm::scc_iterator<const CallGraph *> scci =
           llvm::scc_begin<const CallGraph *>(&call_graph);
       !scci.isAtEnd(); ++scci) {
    if (scci.hasCycle()) {
      auto err = module.emitError()
                 << "A recursive call graph cannot be transformed to "

        ? SortedSetTestSuiteBuilder.using((TestSortedSetGenerator<K>) keySetGenerator)
        : SetTestSuiteBuilder.using(keySetGenerator);
  }

  /**
   * To avoid infinite recursion, test suites with these marker features won't have derived suites
   * created for them.
   */
  enum NoRecurse implements Feature<@Nullable Void> {
    SUBMAP,
    DESCENDING;

    @Override

    /**
     * Helper class to traverse graph. Required to make the containing method thread-safe
     * and yet use class level data to lessen stack usage in recursion
     */
    private class ClasspathGraphVisitor {
        MetadataGraph graph;

        ClasspathContainer cpc;

        List<MetadataGraphVertex> visited;

		}
		return []string{pattern}, nil
	}

	dir, file := path.Split(pattern)
	dir = cleanGlobPath(dir)

	if !hasMeta(dir) {
		return glob(fsys, dir, file, nil)
	}

	// Prevent infinite recursion. See issue 15879.
	if dir == pattern {
		return nil, path.ErrBadPattern
	}

	var m []string
	m, err = globWithLimit(fsys, dir, depth+1)
	if err != nil {
		return nil, err
	}
	for _, d := range m {

				// for circular ref, return an empty object as placeholder
				SchemaProps: spec.SchemaProps{Type: []string{"object"}},
			}, nil
		}
		visited.Insert(ref)
		// restore visited state at the end of the recursion.
		defer func() {
			visited.Delete(ref)
		}()
		// replace the whole schema with the referred one.
		resolved, ok := schemaOf(ref)
		if !ok {

(Karatsuba multiplication is implemented in func karatsuba in nat.go.)
That makes the overall recursive division algorithm take O(n^1.6) time as well,
which is an improvement, but again only for large enough numbers.

It is not critical to make sure that every recursion does only two recursive
calls. While in general the number of recursive calls can change the time
analysis, in this case doing three calls does not change the analysis:

 * ```
 * ok
 * (ok)
 * ((ok))
 * (((ok)))
 * ```
 *
 * **WARNING** care must be taken to avoid infinite recursion, the delegate parser should always have
 * an input consuming parser at its front (e.g., in `p = paren(p) + p`, the `p` at the right would
 * cause an infinite recursion).
 */
internal
fun <T> reference(): ParserRef<T> = ParserRef()


internal