return nil, &FormatError{0, "invalid magic number", nil}
		}
	}
	offset := int64(4)

	// Read the number of FatArchHeaders that come after the fat_header.
	var narch uint32
	err = binary.Read(sr, binary.BigEndian, &narch)
	if err != nil {
		return nil, &FormatError{offset, "invalid fat_header", nil}
	}
	offset += 4

	if narch < 1 {
		return nil, &FormatError{offset, "file contains no images", nil}
	}

from fastapi.testclient import TestClient

app = FastAPI()


def get_header(*, someheader: str = Header()):
    return someheader


def get_something_else(*, someheader: str = Depends(get_header)):
    return f"{someheader}123"


@app.get("/")
def get_deps(dep1: str = Depends(get_header), dep2: str = Depends(get_something_else)):
    return {"dep1": dep1, "dep2": dep2}

    private static final DateTimeFormatter RCF_3339_DATE_FORMAT = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
        .withLocale(Locale.US)
        .withZone(GMT)

    private static final String DATE_HEADER = 'Mon, 29 Sep 2014 11:04:27 GMT'
    private static final String SERVER_GCS = 'GCS'

    TestDirectoryProvider testDirectoryProvider

    GcsServer(TestDirectoryProvider testDirectoryProvider) {
        super()

    public static final String X_AMZ_UPLOAD_ID = 'VXBsb2FkIElEIGZvciA2aWWpbmcncyBteS1tb3ZpZS5tMnRzIHVwbG9hZA'
    public static final String DATE_HEADER = 'Mon, 29 Sep 2014 11:04:27 GMT'
    public static final String SERVER_AMAZON_S3 = 'AmazonS3'

    TestDirectoryProvider testDirectoryProvider

    S3Server(TestDirectoryProvider testDirectoryProvider) {

      {"out_function_object", &flags->out_function_object,
       "Output object file containing the generated function for the "
       "TensorFlow model."},
      {"out_header", &flags->out_header, "Output header file name."},
      {"out_metadata_object", &flags->out_metadata_object,
       "Output object file name containing optional metadata for the generated "
       "function."},

  string target_triple;
  string target_cpu;
  string target_features;
  string entry_point;
  string cpp_class;
  string out_function_object;
  string out_metadata_object;
  string out_header;
  string out_session_module;
  string mlir_components;
  bool experimental_quantize = false;

  // Sanitizer pass options
  bool sanitize_dataflow = false;
  string sanitize_abilists_dataflow;

  tensorflow::tfcompile::MainFlags flags;
#ifndef __s390x__
  flags.target_triple = "x86_64-pc-linux";
#endif
  flags.out_function_object = "out_model.o";
  flags.out_metadata_object = "out_helper.o";
  flags.out_header = "out.h";
  flags.entry_point = "entry";
  flags.debug_info_path_begin_marker = "";

  // Note that tfcompile.bzl's tf_library macro sets fast math flags as that is
  // generally the preferred case.

  string header;
  TF_RETURN_IF_ERROR(GenerateHeader(codegen_opts, config, compile_result,
                                    metadata_result, &header));
  TF_RETURN_IF_ERROR(WriteStringToFile(env, flags.out_header, header));
  return absl::OkStatus();
}

}  // namespace tfcompile

    output_dict["object_files"] = [metadata_object_file, function_object_file]
    if compiler_log_file:
        output_dict["log_files"] = [compiler_log_file]

    output_flags = [
        "--out_header=" + header_file.path,
        "--out_metadata_object=" + metadata_object_file.path,
        "--out_function_object=" + function_object_file.path,
        "--out_session_module=" + session_module_pb.path,
    ]