throws IOException, ServletException {
        final WebApiManagerFactory webApiManagerFactory = ComponentUtil.getWebApiManagerFactory();
        final WebApiManager webApiManager = webApiManagerFactory.get((HttpServletRequest) request);
        if (webApiManager == null) {
            chain.doFilter(request, response);
        } else {

			}
		}
		return "UNSAFEPTR???"
	case "chan int":
		c := key.Interface().(chan int)
		for i := range chans {
			if c == chans[i] {
				return fmt.Sprintf("CHAN%d", i)
			}
		}
		return "CHAN???"
	default:
		return fmt.Sprint(key)
	}
}

var (
	ints  [3]int
	chans = makeChans()
	pin   runtime.Pinner
)

func makeChans() []chan int {

        @Override
        BuildCacheService createBuildCacheService(TestRemoteBuildCache configuration, Describer describer) {
            def chain = describer.type("remote")
            if (configuration.value != null) {
                chain.config("value", configuration.value)
            }
            new TestRemoteBuildCacheService()
        }
    }

     */
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        if (!(request instanceof HttpServletRequest && response instanceof HttpServletResponse)) {
            chain.doFilter(request, response);
            return;
        }

        HttpServletRequest httpRequest = (HttpServletRequest) request;

            normalizer = new LangAnalyzerNormalizer(null);
        } else {
            final NormalizerChain chain = new NormalizerChain();
            for (final String lang : langs) {
                chain.add(new LangAnalyzerNormalizer(lang));
            }
            normalizer = chain;
        }
        return normalizer.normalize(text, field);
    }

module attributes {tf.versions = {bad_consumers = [], min_consumer = 12 : i32, producer = 293 : i32}} {

// CHECK-LABEL: func @gather
// CHECK-SAME: ([[in_chain:%.*]]: !tfrt.chain
// CHECK-SAME: [[arg0:%.*]]: !tfrt_fallback.tf_tensor, [[arg1:%.*]]: !tfrt_fallback.tf_tensor)
// CHECK: [[const:%.*]] = tfrt_fallback_async.const_dense_tensor

    val chain = newChain(call)
    return RealRoutePlanner(
      taskRunner = client.taskRunner,
      connectionPool = client.connectionPool.delegate,
      readTimeoutMillis = client.readTimeoutMillis,
      writeTimeoutMillis = client.writeTimeoutMillis,
      socketConnectTimeoutMillis = chain.connectTimeoutMillis,
      socketReadTimeoutMillis = chain.readTimeoutMillis,

    @Override
    String normalize(String commandOutput, ExecutionMetadata executionMetadata) {
        return commandOutput
            .replaceAll("Tool chain '[\\w+\\-]+' \\([\\w\\- ]+\\)","Tool chain 'clang' (Clang)")
            .replaceAll("platform '[\\w+\\-]+'","platform 'current'")
            .replaceAll("(build/libs/.+/shared/(\\w+))\\.so") { "${it[1]}.dylib" }

            converter = new LangAnayzerConverter(null);
        } else {
            final ReadingConverterChain chain = new ReadingConverterChain();
            for (final String lang : langs) {
                chain.addConverter(new LangAnayzerConverter(lang));
            }
            converter = chain;
        }
        return converter.convert(text, field);
    }

  // CHECK:       [[pred:%.*]] = tfrt_fallback_async.predicate
  // CHECK-NEXT:  tfrt.while [[pred]] @"[[while_func_prefix:.*]]/tfrt_body_1"
  // CHECK-SAME:  (!tfrt.chain, !tfrt_fallback.tf_tensor) -> (!tfrt.chain, !tfrt_fallback.tf_tensor)
  // CHECK-NOT:   func.call
  func.func @while_test_remove_unused_results(%arg0: tensor<i32>, %arg1: tensor<i32>) -> (tensor<i32>, tensor<i32>) {